refactor(core): move image config into state

bun.lock

@@ -121,7 +121,6 @@
       },
       "dependencies": {
         "@agentclientprotocol/sdk": "1.2.1",
-        "@clack/prompts": "1.0.0-alpha.1",
         "@effect/platform-node": "catalog:",
         "@opencode-ai/client": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",

packages/ai/src/protocols/gemini.ts

@@ -92,7 +92,7 @@ const GeminiFunctionCallPart = Schema.Struct({
   functionCall: Schema.Struct({
     id: Schema.optional(Schema.String),
     name: Schema.String,
-    args: Schema.optional(Schema.Unknown),
+    args: Schema.Unknown,
   }),
   thoughtSignature: Schema.optional(Schema.String),
 })
@@ -190,19 +190,8 @@ const GeminiCandidate = Schema.Struct({
   finishReason: Schema.optional(Schema.String),
 })
 
-const GeminiPromptFeedback = Schema.StructWithRest(
-  Schema.Struct({
-    blockReason: Schema.optional(Schema.String),
-    blockReasonMessage: Schema.optional(Schema.String),
-    safetyRatings: Schema.optional(Schema.Unknown),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
-type GeminiPromptFeedback = Schema.Schema.Type<typeof GeminiPromptFeedback>
-
 const GeminiEvent = Schema.Struct({
   candidates: optionalArray(GeminiCandidate),
-  promptFeedback: Schema.optional(GeminiPromptFeedback),
   usageMetadata: Schema.optional(GeminiUsage),
 })
 type GeminiEvent = Schema.Schema.Type<typeof GeminiEvent>
@@ -211,7 +200,6 @@ interface ParserState {
   readonly finishReason?: string
   readonly hasToolCalls: boolean
   readonly nextToolCallId: number
-  readonly promptFeedback?: GeminiPromptFeedback
   readonly usage?: Usage
   readonly lifecycle: Lifecycle.State
   readonly reasoningSignature?: string
@@ -515,37 +503,32 @@ const mapFinishReason = (finishReason: string | undefined, hasToolCalls: boolean
   return "unknown"
 }
 
-const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
-  const promptBlockReason = state.finishReason === undefined ? state.promptFeedback?.blockReason : undefined
-  const finishReason = state.finishReason ?? promptBlockReason
-  if (finishReason === undefined && state.usage === undefined) return []
-
-  const events: LLMEvent[] = []
-  const lifecycle = state.reasoningSignature
-    ? Lifecycle.reasoningEnd(
-        state.lifecycle,
-        events,
-        "reasoning-0",
-        googleMetadata({ thoughtSignature: state.reasoningSignature }),
-      )
-    : state.lifecycle
-  Lifecycle.finish(lifecycle, events, {
-    reason: {
-      normalized:
-        promptBlockReason === undefined ? mapFinishReason(finishReason, state.hasToolCalls) : "content-filter",
-      raw: finishReason,
-    },
-    usage: state.usage,
-    providerMetadata:
-      state.promptFeedback === undefined ? undefined : googleMetadata({ promptFeedback: state.promptFeedback }),
-  })
-  return events
-}
+const finish = (state: ParserState): ReadonlyArray<LLMEvent> =>
+  state.finishReason || state.usage
+    ? (() => {
+        const events: LLMEvent[] = []
+        const lifecycle = state.reasoningSignature
+          ? Lifecycle.reasoningEnd(
+              state.lifecycle,
+              events,
+              "reasoning-0",
+              googleMetadata({ thoughtSignature: state.reasoningSignature }),
+            )
+          : state.lifecycle
+        Lifecycle.finish(lifecycle, events, {
+          reason: {
+            normalized: mapFinishReason(state.finishReason, state.hasToolCalls),
+            raw: state.finishReason,
+          },
+          usage: state.usage,
+        })
+        return events
+      })()
+    : []
 
 const step = (state: ParserState, event: GeminiEvent) => {
   const nextState = {
     ...state,
-    promptFeedback: event.promptFeedback ?? state.promptFeedback,
     usage: event.usageMetadata ? (mapUsage(event.usageMetadata) ?? state.usage) : state.usage,
   }
   const candidate = event.candidates?.[0]
@@ -586,7 +569,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
     }
 
     if ("functionCall" in part) {
-      const input = part.functionCall.args === undefined ? {} : part.functionCall.args
+      const input = part.functionCall.args
       const id = `tool_${nextToolCallId++}`
       const metadata = {
         ...(part.functionCall.id === undefined ? {} : { functionCallId: part.functionCall.id }),

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

@@ -767,31 +767,6 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("defaults omitted function call args to an empty object", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          tools: [ToolDefinition.make({ name: "ping", description: "Ping", inputSchema: { type: "object" } })],
-        }),
-      ).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents({
-              candidates: [
-                {
-                  content: { role: "model", parts: [{ functionCall: { name: "ping" } }] },
-                  finishReason: "STOP",
-                },
-              ],
-            }),
-          ),
-        ),
-      )
-
-      expect(response.toolCalls).toEqual([{ type: "tool-call", id: "tool_0", name: "ping", input: {} }])
-    }),
-  )
-
   it.effect("maps tool calls without a finish reason", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(
@@ -887,51 +862,6 @@ describe("Gemini route", () => {
     }),
   )
 
-  it.effect("preserves candidate-less prompt safety blocks as content-filter outcomes", () =>
-    Effect.gen(function* () {
-      const blocked = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents({
-              promptFeedback: {
-                blockReason: "FUTURE_SAFETY_REASON",
-                blockReasonMessage: "Prompt blocked",
-                safetyRatings: [{ category: "HARM_CATEGORY_HARASSMENT", blocked: true }],
-              },
-            }),
-          ),
-        ),
-      )
-      const blockedWithUsage = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { promptFeedback: { blockReason: "SAFETY" } },
-              { usageMetadata: { promptTokenCount: 7, totalTokenCount: 7 } },
-            ),
-          ),
-        ),
-      )
-
-      expect(blocked.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "finish"])
-      expect(blocked.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "content-filter", raw: "FUTURE_SAFETY_REASON" },
-        providerMetadata: {
-          google: {
-            promptFeedback: {
-              blockReason: "FUTURE_SAFETY_REASON",
-              blockReasonMessage: "Prompt blocked",
-              safetyRatings: [{ category: "HARM_CATEGORY_HARASSMENT", blocked: true }],
-            },
-          },
-        },
-      })
-      expect(blockedWithUsage.finishReason).toEqual({ normalized: "content-filter", raw: "SAFETY" })
-      expect(blockedWithUsage.usage).toMatchObject({ inputTokens: 7, totalTokens: 7 })
-    }),
-  )
-
   it.effect("maps current blocking and invalid-output finish reasons", () =>
     Effect.gen(function* () {
       const reasons = [

packages/cli/package.json

@@ -23,7 +23,6 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
-    "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "catalog:",
     "@opencode-ai/client": "workspace:*",
     "@opencode-ai/plugin": "workspace:*",

packages/cli/src/commands/commands.ts

@@ -86,37 +86,12 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
       ],
     }),
     Spec.make("auth", {
-      description: "manage AI providers and credentials",
+      description: "Manage authentication",
       commands: [
-        Spec.make("list", {
-          description: "list providers and credentials",
-          params: {
-            ...ServerParams,
-            format: Flag.choice("format", ["default", "json"]).pipe(
-              Flag.withDescription("Output format"),
-              Flag.withDefault("default"),
-            ),
-          },
-        }),
         Spec.make("login", {
-          description: "log in to a provider",
+          description: "Log in to a well-known authentication provider",
           params: {
-            ...ServerParams,
-            target: Argument.string("target").pipe(
-              Argument.withDescription("Integration ID, name, or well-known provider URL"),
-              Argument.optional,
-            ),
-            method: Flag.string("method").pipe(Flag.withDescription("Authentication method ID"), Flag.optional),
-          },
-        }),
-        Spec.make("logout", {
-          description: "log out from a configured provider",
-          params: {
-            ...ServerParams,
-            target: Argument.string("target").pipe(
-              Argument.withDescription("Integration ID or name"),
-              Argument.optional,
-            ),
+            url: Argument.string("url").pipe(Argument.withDescription("Well-known provider URL")),
           },
         }),
       ],

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

@@ -1,155 +0,0 @@
-import { confirm, log, multiselect, password, select, text, type Option } from "@clack/prompts"
-import { Effect } from "effect"
-import type { FormAnswer, FormField, FormFields } from "@opencode-ai/client"
-import { openUrl, prompt, requireInteractive } from "../../../ui/prompt"
-
-const skip = Symbol("skip")
-const custom = Symbol("custom")
-
-export const answerForm = Effect.fn("cli.auth.form")(function* (fields: FormFields | undefined) {
-  if (!fields) return undefined
-  yield* requireInteractive("Authentication form input requires an interactive terminal")
-  const answer: FormAnswer = {}
-  for (const field of fields) {
-    if (!active(field, answer)) continue
-    const value = yield* answerField(field)
-    if (value !== undefined) answer[field.key] = value
-  }
-  return answer
-})
-
-export const secret = Effect.fn("cli.auth.secret")(function* (message: string) {
-  yield* requireInteractive("API key input requires an interactive terminal")
-  return yield* prompt<string>(() => password({ message, validate: (value) => (!value ? "Required" : undefined) }))
-})
-
-const answerField = Effect.fn("cli.auth.form.field")(function* (field: FormField) {
-  const message = field.title ?? field.key
-  if (field.description) log.info(field.description)
-  if (field.type === "external") {
-    log.info(field.url)
-    yield* openUrl(field.url)
-    const acknowledged = yield* prompt<boolean>(() =>
-      confirm({ message: message || "Continue after completing this step?", initialValue: true }),
-    )
-    if (!acknowledged) return yield* Effect.fail(new Error(`${message || "External step"} is required`))
-    return true
-  }
-  if (field.type === "boolean") {
-    if (field.required) return yield* prompt<boolean>(() => confirm({ message, initialValue: field.default ?? true }))
-    const options: Array<Option<boolean | typeof skip>> = [
-      { value: true, label: "Yes" },
-      { value: false, label: "No" },
-      { value: skip, label: "Skip" },
-    ]
-    const value = yield* prompt<boolean | typeof skip>(() =>
-      select<boolean | typeof skip>({
-        message,
-        options,
-        initialValue: field.default ?? skip,
-      }),
-    )
-    if (value === skip) return undefined
-    return value
-  }
-  if (field.type === "multiselect") {
-    const options: Array<Option<string | typeof custom>> = field.options.map((option) => ({
-      value: option.value,
-      label: option.label,
-      hint: option.description,
-    }))
-    if (field.custom) options.push({ value: custom, label: "Type another value" })
-    const values = yield* prompt<Array<string | typeof custom>>(() =>
-      multiselect<string | typeof custom>({
-        message,
-        options,
-        initialValues: field.default,
-        required: field.required || (field.minItems ?? 0) > 0,
-      }),
-    )
-    const selected = values.filter((value): value is string => value !== custom)
-    if (values.includes(custom)) {
-      selected.push(yield* prompt<string>(() => text({ message: "Enter value", validate: required })))
-    }
-    const invalid = validateMultiselect(field, selected)
-    if (invalid) return yield* Effect.fail(new Error(invalid))
-    return selected
-  }
-  if (field.type === "string" && field.options) {
-    const options: Array<Option<string | typeof custom | typeof skip>> = field.options.map((option) => ({
-      value: option.value,
-      label: option.label,
-      hint: option.description,
-    }))
-    if (field.custom) options.push({ value: custom, label: "Type your own answer" })
-    if (!field.required) options.push({ value: skip, label: "Skip" })
-    const value = yield* prompt<string | typeof custom | typeof skip>(() =>
-      select<string | typeof custom | typeof skip>({ message, options, initialValue: field.default }),
-    )
-    if (value === skip) return undefined
-    if (value !== custom) return value
-  }
-  const value = yield* prompt<string>(() =>
-    text({
-      message,
-      placeholder: field.type === "string" ? field.placeholder : undefined,
-      initialValue: field.default === undefined ? undefined : String(field.default),
-      validate: (input) => validateText(field, input),
-    }),
-  )
-  if (!value && !field.required) return undefined
-  if (field.type === "string") return value
-  return Number(value)
-})
-
-function active(field: FormField, answer: FormAnswer) {
-  if (field.type === "external" || !field.when) return true
-  return field.when.every((condition) => {
-    const value = answer[condition.key]
-    if (value === undefined) return false
-    const matches = Array.isArray(value) ? value.includes(String(condition.value)) : value === condition.value
-    return condition.op === "eq" ? matches : !matches
-  })
-}
-
-function required(value: string | undefined) {
-  return value ? undefined : "Required"
-}
-
-function validateText(field: Exclude<FormField, { type: "boolean" | "external" | "multiselect" }>, value?: string) {
-  if (!value) return field.required ? "Required" : undefined
-  if (field.type === "number" || field.type === "integer") {
-    const number = Number(value)
-    if (!Number.isFinite(number)) return "Expected a number"
-    if (field.type === "integer" && !Number.isInteger(number)) return "Expected an integer"
-    if (typeof field.minimum === "number" && number < field.minimum) return `Must be at least ${field.minimum}`
-    if (typeof field.maximum === "number" && number > field.maximum) return `Must be at most ${field.maximum}`
-    return undefined
-  }
-  if (field.minLength !== undefined && value.length < field.minLength)
-    return `Must be at least ${field.minLength} characters`
-  if (field.maxLength !== undefined && value.length > field.maxLength)
-    return `Must be at most ${field.maxLength} characters`
-  if (field.pattern) {
-    try {
-      if (!new RegExp(field.pattern).test(value)) return "Invalid format"
-    } catch {
-      return "Invalid format"
-    }
-  }
-  if (field.format === "uri" && !URL.canParse(value)) return "Expected a URL"
-  if (field.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return "Expected an email address"
-  if (field.format === "date") {
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return "Expected a date"
-    const date = new Date(`${value}T00:00:00.000Z`)
-    if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== value) return "Expected a date"
-  }
-  if (field.format === "date-time" && Number.isNaN(Date.parse(value))) return "Expected a date and time"
-  return undefined
-}
-
-function validateMultiselect(field: Extract<FormField, { type: "multiselect" }>, value: string[]) {
-  if (field.minItems !== undefined && value.length < field.minItems) return `Select at least ${field.minItems}`
-  if (field.maxItems !== undefined && value.length > field.maxItems) return `Select at most ${field.maxItems}`
-  return undefined
-}

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

@@ -1,42 +0,0 @@
-import { EOL } from "node:os"
-import { Effect, Option } from "effect"
-import { Commands } from "../../commands"
-import { Runtime } from "../../../framework/runtime"
-import { createClient, loadIntegrations } from "./shared"
-import { handleCommandErrors } from "../../../ui/prompt"
-
-export default Runtime.handler(Commands.commands.auth.commands.list, (input) => list(input).pipe(handleCommandErrors))
-
-const list = Effect.fn("cli.auth.list")(function* (input) {
-  const client = yield* createClient({ server: Option.getOrUndefined(input.server), standalone: input.standalone })
-  const integrations = (yield* loadIntegrations(client)).filter((integration) => integration.connections.length > 0)
-  if (input.format === "json") {
-    process.stdout.write(
-      JSON.stringify(
-        integrations.map((integration) => ({
-          id: integration.id,
-          name: integration.name,
-          connections: integration.connections,
-        })),
-        null,
-        2,
-      ) + EOL,
-    )
-    return
-  }
-  const rows = integrations.flatMap((integration) =>
-    integration.connections.map((connection) => ({
-      integration: integration.name,
-      source: connection.type === "credential" ? connection.label : connection.name,
-      type: connection.type === "credential" ? "stored" : "environment",
-    })),
-  )
-  if (rows.length === 0) {
-    process.stdout.write("No authenticated integrations" + EOL)
-    return
-  }
-  const width = Math.max(...rows.map((row) => row.integration.length)) + 2
-  process.stdout.write(
-    rows.map((row) => row.integration.padEnd(width) + row.source.padEnd(28) + row.type).join(EOL) + EOL,
-  )
-})

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

@@ -1,269 +1,52 @@
-import { autocomplete, intro, log, outro, select, spinner, text } from "@clack/prompts"
-import { Effect, Option } from "effect"
-import type { FormAnswer, IntegrationInfo, OpenCodeClient } from "@opencode-ai/client"
+import { EOL } from "node:os"
+import { Effect } from "effect"
+import { Service } from "@opencode-ai/client/effect/service"
+import { OpenCode, type IntegrationCommandStatusOutput, type OpenCodeClient } from "@opencode-ai/client/promise"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { handlePromptErrors, openUrl, prompt, requireInteractive } from "../../../ui/prompt"
-import { answerForm, secret } from "./form"
-import {
-  createClient,
-  connectMethods,
-  loadIntegrations,
-  location,
-  methodID,
-  methodLabel,
-  request,
-  resolveIntegration,
-  resolveMethod,
-  type ConnectMethod,
-} from "./shared"
+import { ServiceConfig } from "../../../services/service-config"
 
-const integrationPriority = new Map([
-  ["opencode", 0],
-  ["opencode-go", 1],
-  ["openai", 2],
-  ["github-copilot", 3],
-  ["google", 4],
-  ["anthropic", 5],
-  ["openrouter", 6],
-  ["vercel", 7],
-])
+const location = { directory: process.cwd() }
 
 export default Runtime.handler(
   Commands.commands.auth.commands.login,
-  Effect.fn("cli.auth.login")((input) =>
-    login({
-      target: Option.getOrUndefined(input.target),
-      method: Option.getOrUndefined(input.method),
-      server: Option.getOrUndefined(input.server),
-      standalone: input.standalone,
-    }).pipe(handlePromptErrors),
-  ),
+  Effect.fn("cli.auth.login")(function* (input) {
+    process.stdout.write("Logging in..." + EOL + EOL)
+    const endpoint = yield* Service.ensure(yield* ServiceConfig.options())
+    const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
+    yield* request(() => client.integration.wellknown.add({ url: input.url, location }))
+    const integrationID = input.url.replace(/\/+$/, "")
+    const started = yield* request(() =>
+      client.integration.command.connect({ integrationID, methodID: "login", location }),
+    )
+    yield* Effect.addFinalizer(() =>
+      request(() =>
+        client.integration.command.cancel({ integrationID, attemptID: started.data.attemptID, location }),
+      ).pipe(Effect.ignore),
+    )
+
+    const status = yield* wait(client, integrationID, started.data.attemptID)
+    if (status.status === "failed") return yield* Effect.fail(new Error(status.message))
+    if (status.status === "expired") return yield* Effect.fail(new Error("Authentication expired"))
+    process.stdout.write("Logged in" + EOL)
+  }),
 )
 
-const login = Effect.fn("cli.auth.login.run")(function* (input: {
-  target?: string
-  method?: string
-  server?: string
-  standalone: boolean
-}) {
-  if (!input.target)
-    yield* requireInteractive("Pass an integration ID or name when running without an interactive terminal")
-  intro("Connect an integration")
-  const client = yield* createClient({ server: input.server, standalone: input.standalone })
-  const integration = yield* findIntegration(client, input.target)
-  const methods = connectMethods(integration)
-  if (methods.length === 0) yield* Effect.fail(new Error(`${integration.name} has no interactive login methods`))
-  const method = yield* chooseMethod(methods, input.method)
-  const answer = method.type === "command" ? undefined : yield* answerForm(method.form)
-  yield* authenticate(client, integration, method, answer)
-  outro("Done")
-})
-
-const findIntegration = Effect.fn("cli.auth.login.integration")(function* (client: OpenCodeClient, target?: string) {
-  if (target && isURL(target)) {
-    const progress = spinner()
-    progress.start("Discovering authentication provider...")
-    yield* request((signal) => client.integration.wellknown.add({ url: target, location }, { signal })).pipe(
-      Effect.tap(() => Effect.sync(() => progress.stop("Authentication provider discovered"))),
-      Effect.tapCause(() => Effect.sync(() => progress.stop("Discovery failed", 1))),
-    )
-  }
-  const integrations = yield* loadIntegrations(client)
-  if (target) return yield* resolveIntegration(integrations, target)
-  const available = integrations
-    .filter((integration) => connectMethods(integration).length > 0)
-    .toSorted(
-      (a, b) =>
-        (integrationPriority.get(a.id) ?? integrationPriority.size) -
-          (integrationPriority.get(b.id) ?? integrationPriority.size) ||
-        a.name.localeCompare(b.name) ||
-        a.id.localeCompare(b.id),
-    )
-  if (available.length === 0) return yield* Effect.fail(new Error("No authentication integrations are available"))
-  const id = yield* prompt<string>(() =>
-    autocomplete({
-      message: "Select integration",
-      maxItems: 8,
-      options: available.map((integration) => {
-        const option = { value: integration.id, label: integration.name, hint: integration.id }
-        if (integration.connections.length > 0) return { ...option, hint: "connected" }
-        if (integration.id === "opencode") return { ...option, hint: "recommended" }
-        return option
-      }),
-    }),
-  )
-  return yield* resolveIntegration(available, id)
-})
-
-const chooseMethod = Effect.fn("cli.auth.login.method")(function* (methods: ConnectMethod[], target?: string) {
-  if (target) return yield* resolveMethod(methods, target)
-  if (methods.length === 1) return methods[0]
-  yield* requireInteractive("Pass --method when running without an interactive terminal")
-  const id = yield* prompt<string>(() =>
-    select({
-      message: "Select login method",
-      options: methods.map((method) => ({ value: methodID(method), label: methodLabel(method) })),
-    }),
-  )
-  return yield* resolveMethod(methods, id)
-})
-
-const authenticate = Effect.fn("cli.auth.login.authenticate")(function* (
-  client: OpenCodeClient,
-  integration: IntegrationInfo,
-  method: ConnectMethod,
-  answer?: FormAnswer,
-) {
-  if (method.type === "key") return yield* keyLogin(client, integration, method, answer)
-  if (method.type === "command") return yield* commandLogin(client, integration, method)
-  return yield* oauthLogin(client, integration, method, answer)
-})
-
-const keyLogin = Effect.fn("cli.auth.login.key")(function* (
-  client: OpenCodeClient,
-  integration: IntegrationInfo,
-  method: Extract<ConnectMethod, { type: "key" }>,
-  answer?: FormAnswer,
-) {
-  const key = yield* secret(method.label ?? `Enter your ${integration.name} API key`)
-  const progress = spinner()
-  progress.start("Saving credential...")
-  yield* request((signal) =>
-    client.integration.connect.key({ integrationID: integration.id, key, answer, location }, { signal }),
-  ).pipe(
-    Effect.tap(() => Effect.sync(() => progress.stop(`Connected to ${integration.name}`))),
-    Effect.tapCause(() => Effect.sync(() => progress.stop("Authentication failed", 1))),
-  )
-})
-
-const oauthLogin = Effect.fn("cli.auth.login.oauth")(function* (
-  client: OpenCodeClient,
-  integration: IntegrationInfo,
-  method: Extract<ConnectMethod, { type: "oauth" }>,
-  answer?: FormAnswer,
-) {
-  const progress = spinner()
-  progress.start("Starting authorization...")
-  const started = yield* request((signal) =>
-    client.integration.oauth.connect(
-      { integrationID: integration.id, methodID: method.id, answer, location },
-      { signal },
-    ),
-  ).pipe(Effect.tapCause(() => Effect.sync(() => progress.stop("Authentication failed", 1))))
-  const attempt = started.data
-  yield* Effect.addFinalizer(() =>
-    request(() =>
-      client.integration.oauth.cancel(
-        { integrationID: integration.id, attemptID: attempt.attemptID, location },
-        { signal: AbortSignal.timeout(5_000) },
-      ),
-    ).pipe(Effect.ignore),
-  )
-  progress.stop("Authorization started")
-  log.info(attempt.instructions)
-  log.info(attempt.url)
-  if (process.stdin.isTTY && process.stdout.isTTY) yield* openUrl(attempt.url)
-
-  if (attempt.mode === "code") {
-    yield* requireInteractive("This login requires an interactive terminal to enter the authorization code")
-    const code = yield* prompt<string>(() =>
-      text({ message: "Paste the authorization code", validate: (value) => (!value ? "Required" : undefined) }),
-    )
-    const completing = spinner()
-    completing.start("Completing authorization...")
-    yield* request((signal) =>
-      client.integration.oauth.complete(
-        { integrationID: integration.id, attemptID: attempt.attemptID, code, location },
-        { signal },
-      ),
-    ).pipe(
-      Effect.tap(() => Effect.sync(() => completing.stop(`Connected to ${integration.name}`))),
-      Effect.tapCause(() => Effect.sync(() => completing.stop("Authentication failed", 1))),
-    )
-    return
-  }
-
-  const waiting = spinner()
-  waiting.start("Waiting for authorization...")
-  const status = yield* waitForOAuth(client, integration.id, attempt.attemptID).pipe(
-    Effect.tapCause(() => Effect.sync(() => waiting.stop("Authentication failed", 1))),
-  )
-  if (status.status === "complete") {
-    waiting.stop(`Connected to ${integration.name}`)
-    return
-  }
-  waiting.stop("Authentication failed", 1)
-  if (status.status === "failed") yield* Effect.fail(new Error(status.message))
-  yield* Effect.fail(new Error("Authorization expired"))
-})
-
-const commandLogin = Effect.fn("cli.auth.login.command")(function* (
-  client: OpenCodeClient,
-  integration: IntegrationInfo,
-  method: Extract<ConnectMethod, { type: "command" }>,
-) {
-  const progress = spinner()
-  progress.start("Starting authentication command...")
-  const started = yield* request((signal) =>
-    client.integration.command.connect({ integrationID: integration.id, methodID: method.id, location }, { signal }),
-  ).pipe(Effect.tapCause(() => Effect.sync(() => progress.stop("Authentication failed", 1))))
-  yield* Effect.addFinalizer(() =>
-    request(() =>
-      client.integration.command.cancel(
-        {
-          integrationID: integration.id,
-          attemptID: started.data.attemptID,
-          location,
-        },
-        { signal: AbortSignal.timeout(5_000) },
-      ),
-    ).pipe(Effect.ignore),
-  )
-  const status = yield* waitForCommand(client, integration.id, started.data.attemptID, (message) =>
-    progress.message(message.trim() || "Waiting for authentication command..."),
-  ).pipe(Effect.tapCause(() => Effect.sync(() => progress.stop("Authentication failed", 1))))
-  if (status.status === "complete") {
-    progress.stop(`Connected to ${integration.name}`)
-    return
-  }
-  progress.stop("Authentication failed", 1)
-  if (status.status === "failed") yield* Effect.fail(new Error(status.message))
-  yield* Effect.fail(new Error("Authentication expired"))
-})
-
-const waitForOAuth = Effect.fn("cli.auth.login.oauth.wait")(function* (
+const wait = (
   client: OpenCodeClient,
   integrationID: string,
   attemptID: string,
-) {
-  while (true) {
-    const response = yield* request((signal) =>
-      client.integration.oauth.status({ integrationID, attemptID, location }, { signal }),
-    )
+  shown = false,
+): Effect.Effect<Exclude<IntegrationCommandStatusOutput["data"], { status: "pending" }>, unknown> =>
+  Effect.gen(function* () {
+    const response = yield* request(() => client.integration.command.status({ integrationID, attemptID, location }))
     if (response.data.status !== "pending") return response.data
+    const output = response.data.message?.trim()
+    if (!shown && output) process.stdout.write(output + EOL + EOL)
     yield* Effect.sleep(500)
-  }
-})
+    return yield* wait(client, integrationID, attemptID, shown || !!output)
+  })
 
-const waitForCommand = Effect.fn("cli.auth.login.command.wait")(function* (
-  client: OpenCodeClient,
-  integrationID: string,
-  attemptID: string,
-  update: (message: string) => void,
-) {
-  while (true) {
-    const response = yield* request((signal) =>
-      client.integration.command.status({ integrationID, attemptID, location }, { signal }),
-    )
-    if (response.data.status !== "pending") return response.data
-    if (response.data.message) update(response.data.message)
-    yield* Effect.sleep(500)
-  }
-})
-
-function isURL(value: string) {
-  if (!URL.canParse(value)) return false
-  const protocol = new URL(value).protocol
-  return protocol === "http:" || protocol === "https:"
+function request<A>(task: () => Promise<A>) {
+  return Effect.tryPromise({ try: task, catch: (cause) => cause })
 }

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

@@ -1,83 +0,0 @@
-import { autocomplete, intro, outro, spinner } from "@clack/prompts"
-import { Effect, Option } from "effect"
-import type { IntegrationInfo } from "@opencode-ai/client"
-import { Commands } from "../../commands"
-import { Runtime } from "../../../framework/runtime"
-import { handlePromptErrors, prompt, requireInteractive } from "../../../ui/prompt"
-import { createClient, loadIntegrations, location, request, resolveIntegration } from "./shared"
-
-export default Runtime.handler(
-  Commands.commands.auth.commands.logout,
-  Effect.fn("cli.auth.logout")((input) =>
-    logout({
-      target: Option.getOrUndefined(input.target),
-      server: Option.getOrUndefined(input.server),
-      standalone: input.standalone,
-    }).pipe(handlePromptErrors),
-  ),
-)
-
-const logout = Effect.fn("cli.auth.logout.run")(function* (input: {
-  target?: string
-  server?: string
-  standalone: boolean
-}) {
-  if (!input.target)
-    yield* requireInteractive("Pass an integration ID or name when running without an interactive terminal")
-  intro("Remove credential")
-  const client = yield* createClient({ server: input.server, standalone: input.standalone })
-  const integrations = yield* loadIntegrations(client)
-  const integration = yield* chooseIntegration(integrations, input.target)
-  const credentials = integration.connections.filter((connection) => connection.type === "credential")
-  if (credentials.length === 0) {
-    const environment = integration.connections
-      .filter((connection) => connection.type === "env")
-      .map((connection) => connection.name)
-    if (environment.length) {
-      yield* Effect.fail(
-        new Error(
-          `${integration.name} is authenticated through ${environment.join(", ")}; unset the environment variable to disconnect`,
-        ),
-      )
-    }
-    yield* Effect.fail(new Error(`No stored credentials for ${integration.name}`))
-  }
-  const progress = spinner()
-  progress.start("Removing credential...")
-  yield* Effect.forEach(
-    credentials,
-    (connection) =>
-      request((signal) => client.credential.remove({ credentialID: connection.id, location }, { signal })),
-    { concurrency: "unbounded", discard: true },
-  ).pipe(
-    Effect.tap(() => Effect.sync(() => progress.stop(`Disconnected from ${integration.name}`))),
-    Effect.tapCause(() => Effect.sync(() => progress.stop("Failed to remove credential", 1))),
-  )
-  outro("Done")
-})
-
-const chooseIntegration = Effect.fn("cli.auth.logout.integration")(function* (
-  integrations: IntegrationInfo[],
-  target?: string,
-) {
-  if (target) return yield* resolveIntegration(integrations, target)
-  const configured = integrations.filter((integration) =>
-    integration.connections.some((connection) => connection.type === "credential"),
-  )
-  if (configured.length === 0) return yield* Effect.fail(new Error("No stored credentials found"))
-  const id = yield* prompt<string>(() =>
-    autocomplete({
-      message: "Select integration",
-      maxItems: 8,
-      options: configured.map((integration) => ({
-        value: integration.id,
-        label: integration.name,
-        hint: integration.connections
-          .filter((connection) => connection.type === "credential")
-          .map((connection) => connection.label)
-          .join(", "),
-      })),
-    }),
-  )
-  return yield* resolveIntegration(configured, id)
-})

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

@@ -1,73 +0,0 @@
-import { Effect } from "effect"
-import { OpenCode, type IntegrationInfo, type IntegrationMethod, type OpenCodeClient } from "@opencode-ai/client"
-import { Service } from "@opencode-ai/client/effect/service"
-import { ServerConnection } from "../../../services/server-connection"
-
-export const location = { directory: process.cwd() }
-
-export const createClient = Effect.fn("cli.auth.client")(function* (input: ServerConnection.Args) {
-  const server = yield* ServerConnection.resolve(input)
-  return OpenCode.make({ baseUrl: server.endpoint.url, headers: Service.headers(server.endpoint) })
-})
-
-export function request<A>(run: (signal: AbortSignal) => Promise<A>) {
-  return Effect.tryPromise({ try: run, catch: (cause) => cause })
-}
-
-export const loadIntegrations = Effect.fn("cli.auth.integrations")(function* (client: OpenCodeClient) {
-  // The model endpoint is the existing public readiness boundary for the initial plugin generation.
-  yield* request((signal) => client.model.default({ location }, { signal }))
-  return yield* request((signal) => client.integration.list({ location }, { signal })).pipe(
-    Effect.map((response) => response.data),
-  )
-})
-
-export const resolveIntegration = Effect.fn("cli.auth.resolve-integration")(function* (
-  integrations: IntegrationInfo[],
-  target: string,
-) {
-  const normalized = target.replace(/\/+$/, "")
-  const byID = integrations.find((integration) => integration.id === normalized)
-  if (byID) return byID
-  const matches = integrations.filter((integration) => integration.name.toLowerCase() === normalized.toLowerCase())
-  if (matches.length === 1) return matches[0]
-  if (matches.length > 1) {
-    return yield* Effect.fail(
-      new Error(
-        `Integration name "${target}" is ambiguous: ${matches.map((integration) => integration.id).join(", ")}`,
-      ),
-    )
-  }
-  return yield* Effect.fail(new Error(`Integration not found: ${target}`))
-})
-
-export type ConnectMethod = Exclude<IntegrationMethod, { type: "env" }>
-
-export function connectMethods(integration: IntegrationInfo) {
-  return integration.methods
-    .filter((method): method is ConnectMethod => method.type !== "env")
-    .toSorted((a, b) => Number(a.type === "key") - Number(b.type === "key"))
-}
-
-export const resolveMethod = Effect.fn("cli.auth.resolve-method")(function* (methods: ConnectMethod[], target: string) {
-  const normalized = target.toLowerCase()
-  const matches = methods.filter((method) => {
-    if (method.type === "key") return normalized === "key" || method.label?.toLowerCase() === normalized
-    return method.id === target || method.label.toLowerCase() === normalized
-  })
-  if (matches.length === 1) return matches[0]
-  if (matches.length > 1) return yield* Effect.fail(new Error(`Authentication method "${target}" is ambiguous`))
-  const available = methods.map(methodID).join(", ")
-  return yield* Effect.fail(
-    new Error(`Authentication method not found: ${target}${available ? `. Available: ${available}` : ""}`),
-  )
-})
-
-export function methodID(method: ConnectMethod) {
-  return method.type === "key" ? "key" : method.id
-}
-
-export function methodLabel(method: ConnectMethod) {
-  if (method.type === "key") return method.label ?? "API key"
-  return method.label
-}

packages/cli/src/commands/handlers/default.ts

@@ -10,17 +10,15 @@ import { Updater } from "../../services/updater"
 import { UpdatePreflight } from "../../services/update-preflight"
 import { Npm } from "@opencode-ai/util/npm"
 import { OPENCODE_CHANNEL, OPENCODE_VERSION } from "../../version"
-import { Env } from "../../env"
 
 export default Runtime.handler(Commands, (input) =>
   Effect.gen(function* () {
     const requestedDirectory = Option.getOrUndefined(input.directory)
-    const requestedServer = Option.getOrUndefined(input.server)
     if (requestedDirectory !== undefined) process.chdir(requestedDirectory)
     const preflight = UpdatePreflight.make()
     yield* Effect.addFinalizer(() => Effect.promise(() => preflight.close()))
     const server = yield* ServerConnection.resolve({
-      server: requestedServer,
+      server: Option.getOrUndefined(input.server),
       standalone: input.standalone,
       mismatch: "replace",
       onStart: (reason, previousVersion) => {
@@ -77,7 +75,6 @@ export default Runtime.handler(Commands, (input) =>
         resolve: (spec) =>
           runPromise(npm.add(spec, { subpaths: ["tui"] }).pipe(Effect.map((result) => result.entrypoint))),
       },
-      environment: requestedServer === undefined ? Env.session() : undefined,
       terminalHandoff: () => preflight.finish(),
       log: (level, message, tags) => {
         const effect =

packages/cli/src/env.ts

@@ -12,13 +12,4 @@ export const password = Config.redacted("OPENCODE_PASSWORD").pipe(
   Config.withDefault(undefined),
 )
 
-export function session() {
-  return Object.fromEntries(
-    Object.entries(process.env).filter(
-      (entry): entry is [string, string] =>
-        entry[1] !== undefined && entry[0] !== "OPENCODE_PASSWORD" && entry[0] !== "OPENCODE_SERVER_PASSWORD",
-    ),
-  )
-}
-
 export * as Env from "./env"

packages/cli/src/index.ts

@@ -19,9 +19,7 @@ const Handlers = Runtime.handlers(Commands, {
   acp: () => import("./commands/handlers/acp"),
   api: () => import("./commands/handlers/api"),
   auth: {
-    list: () => import("./commands/handlers/auth/list"),
     login: () => import("./commands/handlers/auth/login"),
-    logout: () => import("./commands/handlers/auth/logout"),
   },
   debug: {
     agents: () => import("./commands/handlers/debug/agents"),

packages/cli/src/mini.ts

@@ -5,7 +5,6 @@ import { setTimeout } from "node:timers/promises"
 import { readStdin } from "./util/io"
 import { createMiniHost, INTERACTIVE_INPUT_ERROR, usingInteractiveStdin } from "./mini-host"
 import { parseSessionTargetModel, resolveSessionTarget, type SessionTargetPreparation } from "./session-target"
-import { Env } from "./env"
 
 export type MiniCommandInput = {
   server: {
@@ -39,7 +38,6 @@ export async function runMini(input: MiniCommandInput) {
       const directory = localDirectory()
       const connection = createMiniConnection(input.server)
       const sdk = connection.sdk
-      const environment = input.server.reconnect ? Env.session() : undefined
       const requested = parseModel(input.model)
       const model = requested ? { providerID: requested.providerID, modelID: requested.id } : undefined
       const prepare = prepareTarget(input.agent)
@@ -57,7 +55,6 @@ export async function runMini(input: MiniCommandInput) {
               fork: input.fork,
               model: requested,
               agent: input.agent,
-              environment,
               prepare,
               signal,
             }).catch((error) => {
@@ -92,7 +89,6 @@ export async function runMini(input: MiniCommandInput) {
           client,
           location: { directory: next.location.directory, workspace: next.location.workspaceID },
           agent: next.agent,
-          environment,
           model: next.model
             ? { providerID: next.model.providerID, id: next.model.modelID, variant: next.variant }
             : undefined,

packages/cli/src/run/run.ts

@@ -9,7 +9,6 @@ import { parseSessionTargetModel, resolveSessionTarget } from "../session-target
 import { toolInlineInfo } from "@opencode-ai/tui/mini/tool"
 import { runNonInteractivePrompt } from "./noninteractive"
 import { UI } from "./ui"
-import { Env } from "../env"
 
 export type RunCommandInput = {
   server: ServerConnection.Resolved
@@ -92,7 +91,6 @@ async function execute(input: RunCommandInput, prepared: Prepared, endpoint: End
       ? { providerID: explicit.model.providerID, id: explicit.model.modelID, variant: explicit.variant }
       : undefined,
     agent: input.agent,
-    environment: input.server.service ? Env.session() : undefined,
     prepare: async (next) => {
       const selected =
         next.model ??

packages/cli/src/session-target.ts

@@ -36,7 +36,6 @@ export async function resolveSessionTarget(input: {
   fork?: boolean
   model?: ModelRef
   agent?: string
-  environment?: Readonly<Record<string, string>>
   prepare: SessionTargetPreparation
   signal?: AbortSignal
 }): Promise<SessionTarget> {
@@ -71,12 +70,6 @@ export async function resolveSessionTarget(input: {
       .catch((error) => {
         throw new SessionTargetMutationError(error)
       }))
-  if (input.environment !== undefined && location.workspaceID === undefined)
-    await input.client.session
-      .environment({ sessionID: session.id, variables: input.environment }, ...requestOptions(input.signal))
-      .catch((error) => {
-        throw new SessionTargetMutationError(error)
-      })
   return {
     session,
     location,

packages/cli/src/ui/prompt.ts

@@ -1,69 +0,0 @@
-import { cancel, isCancel, log, outro } from "@clack/prompts"
-import { Effect } from "effect"
-import { EOL } from "node:os"
-
-export class CancelledError extends Error {
-  constructor() {
-    super("Cancelled")
-  }
-}
-
-export function prompt<A>(run: () => Promise<A | symbol>) {
-  return Effect.tryPromise({
-    try: async () => {
-      const value = await run()
-      if (isCancel(value)) throw new CancelledError()
-      return value as A
-    },
-    catch: (cause) => cause,
-  })
-}
-
-export function requireInteractive(message: string) {
-  if (process.stdin.isTTY && process.stdout.isTTY) return Effect.void
-  return Effect.fail(new Error(message))
-}
-
-export const openUrl = Effect.fn("cli.prompt.open-url")(function* (url: string) {
-  const { default: open } = yield* Effect.promise(() => import("open"))
-  yield* Effect.promise(() => open(url)).pipe(Effect.ignore)
-})
-
-export function handlePromptErrors<A, E, R>(effect: Effect.Effect<A, E, R>) {
-  return effect.pipe(
-    Effect.catchIf(
-      (error) => error instanceof CancelledError,
-      () =>
-        Effect.sync(() => {
-          cancel("Cancelled")
-          process.exitCode = 130
-        }),
-    ),
-    Effect.catch((error) =>
-      Effect.sync(() => {
-        log.error(message(error))
-        outro("Failed")
-        process.exitCode = 1
-      }),
-    ),
-  )
-}
-
-export function handleCommandErrors<A, E, R>(effect: Effect.Effect<A, E, R>) {
-  return effect.pipe(
-    Effect.catch((error) =>
-      Effect.sync(() => {
-        process.stderr.write(message(error) + EOL)
-        process.exitCode = 1
-      }),
-    ),
-  )
-}
-
-function message(error: unknown) {
-  if (error instanceof Error) return error.message
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message
-  }
-  return String(error)
-}

packages/cli/test/auth.test.ts

@@ -1,267 +1,20 @@
 import { describe, expect, test } from "bun:test"
 import path from "node:path"
-import { OPENCODE_VERSION } from "../src/version"
 
 describe("auth command", () => {
-  test("registers authentication commands", async () => {
-    const [auth, list, login, logout] = await Promise.all([
-      cli(["auth", "--help"]),
-      cli(["auth", "list", "--help"]),
-      cli(["auth", "login", "--help"]),
-      cli(["auth", "logout", "--help"]),
-    ])
+  test("registers login", async () => {
+    const [auth, login] = await Promise.all([cli(["auth", "--help"]), cli(["auth", "login", "--help"])])
 
     expect(auth.exitCode).toBe(0)
-    expect(auth.stdout).toContain("list")
     expect(auth.stdout).toContain("login")
-    expect(auth.stdout).toContain("logout")
-    expect(auth.stdout).toContain("manage AI providers and credentials")
-    expect(auth.stdout).toContain("list providers and credentials")
-    expect(auth.stdout).toContain("log in to a provider")
-    expect(auth.stdout).toContain("log out from a configured provider")
+    expect(auth.stdout).toContain("Log in to a well-known authentication provider")
     expect(auth.stdout).not.toContain("connect")
-    expect(list.exitCode).toBe(0)
-    expect(list.stdout).toContain("opencode auth list [flags]")
-    expect(list.stdout).toContain("--format")
     expect(login.exitCode).toBe(0)
-    expect(login.stdout).toContain("opencode auth login [flags] [<target>]")
-    expect(login.stdout).toContain("Integration ID, name, or well-known provider URL")
-    expect(login.stdout).toContain("--method")
-    expect(logout.exitCode).toBe(0)
-    expect(logout.stdout).toContain("opencode auth logout [flags] [<target>]")
-  })
-
-  test("lists stored and environment connections", async () => {
-    const requests: string[] = []
-    using server = authServer((request, url) => {
-      if (url.pathname === "/api/integration") {
-        return Response.json(
-          located([
-            {
-              id: "anthropic",
-              name: "Anthropic",
-              methods: [],
-              connections: [
-                { type: "credential", id: "cred_test", label: "default" },
-                { type: "env", name: "ANTHROPIC_API_KEY" },
-              ],
-            },
-            { id: "openai", name: "OpenAI", methods: [], connections: [] },
-          ]),
-        )
-      }
-      return new Response("Not found", { status: 404 })
-    }, requests)
-
-    const result = await cli(["auth", "list", "--format", "json", "--server", server.url.toString()])
-    expect({ exitCode: result.exitCode, stderr: result.stderr }).toEqual({ exitCode: 0, stderr: "" })
-    expect(JSON.parse(result.stdout)).toEqual([
-      {
-        id: "anthropic",
-        name: "Anthropic",
-        connections: [
-          { type: "credential", id: "cred_test", label: "default" },
-          { type: "env", name: "ANTHROPIC_API_KEY" },
-        ],
-      },
-    ])
-    expect(requests.indexOf("/api/model/default")).toBeLessThan(requests.indexOf("/api/integration"))
-  })
-
-  test("runs command authentication without interactive input", async () => {
-    const requests: Array<{ method: string; path: string }> = []
-    using server = authServer((request, url) => {
-      requests.push({ method: request.method, path: url.pathname })
-      if (url.pathname === "/api/integration") {
-        return Response.json(
-          located([
-            {
-              id: "company",
-              name: "Company",
-              methods: [{ id: "login", type: "command", label: "Company login", command: ["company", "login"] }],
-              connections: [],
-            },
-          ]),
-        )
-      }
-      if (url.pathname === "/api/integration/company/connect/command" && request.method === "POST") {
-        return Response.json(located({ attemptID: "con_test", time: { created: 1, expires: 2 } }))
-      }
-      if (url.pathname === "/api/integration/company/connect/command/con_test" && request.method === "GET") {
-        return Response.json(located({ status: "complete", time: { created: 1, expires: 2 } }))
-      }
-      if (url.pathname === "/api/integration/company/connect/command/con_test" && request.method === "DELETE") {
-        return new Response(null, { status: 204 })
-      }
-      return new Response("Not found", { status: 404 })
-    })
-
-    const result = await cli(["auth", "login", "company", "--server", server.url.toString()])
-    expect({ exitCode: result.exitCode, stderr: result.stderr }).toEqual({ exitCode: 0, stderr: "" })
-    expect(result.stdout).toContain("Connected to Company")
-    expect(requests).toContainEqual({ method: "POST", path: "/api/integration/company/connect/command" })
-    expect(requests).toContainEqual({ method: "GET", path: "/api/integration/company/connect/command/con_test" })
-    expect(requests).toContainEqual({ method: "DELETE", path: "/api/integration/company/connect/command/con_test" })
-  })
-
-  test("completes automatic OAuth authentication", async () => {
-    const requests: Array<{ method: string; path: string }> = []
-    using server = authServer((request, url) => {
-      requests.push({ method: request.method, path: url.pathname })
-      if (url.pathname === "/api/integration") {
-        return Response.json(
-          located([
-            {
-              id: "openai",
-              name: "OpenAI",
-              methods: [{ id: "browser", type: "oauth", label: "Browser" }],
-              connections: [],
-            },
-          ]),
-        )
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth" && request.method === "POST") {
-        return Response.json(
-          located({
-            attemptID: "con_oauth",
-            url: "https://example.com/authorize",
-            instructions: "Authorize OpenAI",
-            mode: "auto",
-            time: { created: 1, expires: 2 },
-          }),
-        )
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth/con_oauth" && request.method === "GET") {
-        return Response.json(located({ status: "complete", time: { created: 1, expires: 2 } }))
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth/con_oauth" && request.method === "DELETE") {
-        return new Response(null, { status: 204 })
-      }
-      return new Response("Not found", { status: 404 })
-    })
-
-    const result = await cli(["auth", "login", "openai", "--server", server.url.toString()])
-    expect({ exitCode: result.exitCode, stderr: result.stderr }).toEqual({ exitCode: 0, stderr: "" })
-    expect(result.stdout).toContain("https://example.com/authorize")
-    expect(result.stdout).toContain("Connected to OpenAI")
-    expect(requests).toContainEqual({ method: "POST", path: "/api/integration/openai/connect/oauth" })
-    expect(requests).toContainEqual({ method: "GET", path: "/api/integration/openai/connect/oauth/con_oauth" })
-    expect(requests).toContainEqual({ method: "DELETE", path: "/api/integration/openai/connect/oauth/con_oauth" })
-  })
-
-  test("settles the OAuth spinner when status polling fails", async () => {
-    using server = authServer((request, url) => {
-      if (url.pathname === "/api/integration") {
-        return Response.json(
-          located([
-            {
-              id: "openai",
-              name: "OpenAI",
-              methods: [{ id: "browser", type: "oauth", label: "Browser" }],
-              connections: [],
-            },
-          ]),
-        )
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth" && request.method === "POST") {
-        return Response.json(
-          located({
-            attemptID: "con_oauth",
-            url: "https://example.com/authorize",
-            instructions: "Authorize OpenAI",
-            mode: "auto",
-            time: { created: 1, expires: 2 },
-          }),
-        )
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth/con_oauth" && request.method === "GET") {
-        return new Response("Unavailable", { status: 500 })
-      }
-      if (url.pathname === "/api/integration/openai/connect/oauth/con_oauth" && request.method === "DELETE") {
-        return new Response(null, { status: 204 })
-      }
-      return new Response("Not found", { status: 404 })
-    })
-
-    const result = await cli(["auth", "login", "openai", "--server", server.url.toString()])
-    expect(result.exitCode).toBe(1)
-    expect(result.stdout).toContain("Authentication failed")
-    expect(result.stdout).toContain("Failed")
-    expect(result.stdout).not.toContain("\n    at ")
-  })
-
-  test("removes stored credentials", async () => {
-    const removed: string[] = []
-    using server = authServer((request, url) => {
-      if (url.pathname === "/api/integration") {
-        return Response.json(
-          located([
-            {
-              id: "anthropic",
-              name: "Anthropic",
-              methods: [{ type: "key" }],
-              connections: [{ type: "credential", id: "cred_test", label: "default" }],
-            },
-          ]),
-        )
-      }
-      if (url.pathname === "/api/credential/cred_test" && request.method === "DELETE") {
-        removed.push("cred_test")
-        return new Response(null, { status: 204 })
-      }
-      return new Response("Not found", { status: 404 })
-    })
-
-    const result = await cli(["auth", "logout", "anthropic", "--server", server.url.toString()])
-    expect({ exitCode: result.exitCode, stderr: result.stderr }).toEqual({ exitCode: 0, stderr: "" })
-    expect(result.stdout).toContain("Disconnected from Anthropic")
-    expect(removed).toEqual(["cred_test"])
-  })
-
-  test("requires a target outside an interactive terminal", async () => {
-    const result = await cli(["auth", "login"])
-    expect(result.exitCode).toBe(1)
-    expect(result.stdout).toContain("Pass an integration ID or name")
-    expect(result.stdout).not.toContain("Background service failed to start")
-  })
-
-  test("reports list connection failures without a stack trace", async () => {
-    using server = Bun.serve({ port: 0, fetch: () => new Response("Unavailable", { status: 503 }) })
-    const result = await cli(["auth", "list", "--server", server.url.toString()])
-    expect(result.exitCode).toBe(1)
-    expect(result.stdout).toBe("")
-    expect(result.stderr).toContain("did not provide a compatible V2 health response")
-    expect(result.stderr).not.toContain("\n    at ")
+    expect(login.stdout).toContain("opencode auth login [flags] <url>")
+    expect(login.stdout).toContain("Well-known provider URL")
   })
 })
 
-function authServer(fetch: (request: Request, url: URL) => Response | Promise<Response>, requests?: string[]) {
-  return Bun.serve({
-    port: 0,
-    fetch(request) {
-      const url = new URL(request.url)
-      requests?.push(url.pathname)
-      if (url.pathname === "/api/health") return health()
-      if (url.pathname === "/api/model/default") return Response.json(located(null))
-      return fetch(request, url)
-    },
-  })
-}
-
-function health() {
-  return Response.json({ healthy: true, version: OPENCODE_VERSION, pid: process.pid })
-}
-
-function located<T>(data: T) {
-  return {
-    location: {
-      directory: process.cwd(),
-      project: { id: "project", directory: process.cwd(), canonical: process.cwd() },
-    },
-    data,
-  }
-}
-
 async function cli(args: string[]) {
   const child = Bun.spawn([process.execPath, "run", "src/index.ts", ...args], {
     cwd: path.join(import.meta.dir, ".."),

packages/cli/test/env.test.ts

@@ -1,24 +0,0 @@
-import { expect, test } from "bun:test"
-import { Env } from "../src/env"
-
-test("session environment omits server credentials", () => {
-  const previousPassword = process.env.OPENCODE_PASSWORD
-  const previousLegacyPassword = process.env.OPENCODE_SERVER_PASSWORD
-  const previousValue = process.env.OPENCODE_SESSION_ENV_TEST
-  process.env.OPENCODE_PASSWORD = "password"
-  process.env.OPENCODE_SERVER_PASSWORD = "legacy"
-  process.env.OPENCODE_SESSION_ENV_TEST = "included"
-
-  const environment = Env.session()
-
-  if (previousPassword === undefined) delete process.env.OPENCODE_PASSWORD
-  else process.env.OPENCODE_PASSWORD = previousPassword
-  if (previousLegacyPassword === undefined) delete process.env.OPENCODE_SERVER_PASSWORD
-  else process.env.OPENCODE_SERVER_PASSWORD = previousLegacyPassword
-  if (previousValue === undefined) delete process.env.OPENCODE_SESSION_ENV_TEST
-  else process.env.OPENCODE_SESSION_ENV_TEST = previousValue
-
-  expect(environment.OPENCODE_PASSWORD).toBeUndefined()
-  expect(environment.OPENCODE_SERVER_PASSWORD).toBeUndefined()
-  expect(environment.OPENCODE_SESSION_ENV_TEST).toBe("included")
-})

packages/cli/test/session-target.test.ts

@@ -55,26 +55,6 @@ describe("session target resolver", () => {
     expect(target.session.id).toBe("ses_implicit")
   })
 
-  test("attaches the terminal environment to the resolved local Session", async () => {
-    const client = OpenCode.make({ baseUrl: "https://opencode.test" })
-    const selected = session("ses_resume", "/session")
-    spyOn(client.session, "get").mockResolvedValue(selected)
-    spyOn(client.location, "get").mockResolvedValue(location("/session"))
-    const environment = spyOn(client.session, "environment").mockResolvedValue()
-
-    await resolveSessionTarget({
-      client,
-      session: selected.id,
-      environment: { PATH: "/terminal/bin" },
-      prepare,
-    })
-
-    expect(environment).toHaveBeenCalledWith({
-      sessionID: selected.id,
-      variables: { PATH: "/terminal/bin" },
-    })
-  })
-
   test("prepares a fresh Session at the server Location before creation", async () => {
     const client = OpenCode.make({ baseUrl: "https://opencode.test" })
     const order: string[] = []

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

@@ -914,10 +914,6 @@ export type Endpoint5_34Input = { readonly sessionID: Session.ID; readonly messa
 export type Endpoint5_34Output = SessionMessage.Info
 export type SessionMessageOperation<E = never> = (input: Endpoint5_34Input) => Effect.Effect<Endpoint5_34Output, E>
 
-export type Endpoint5_35Input = { readonly sessionID: Session.ID; readonly variables: { readonly [x: string]: string } }
-export type Endpoint5_35Output = void
-export type SessionEnvironmentOperation<E = never> = (input: Endpoint5_35Input) => Effect.Effect<Endpoint5_35Output, E>
-
 export interface SessionApi<E = never> {
   readonly list: SessionListOperation<E>
   readonly create: SessionCreateOperation<E>
@@ -962,7 +958,6 @@ export interface SessionApi<E = never> {
   readonly interrupt: SessionInterruptOperation<E>
   readonly background: SessionBackgroundOperation<E>
   readonly message: SessionMessageOperation<E>
-  readonly environment: SessionEnvironmentOperation<E>
 }
 
 export type Endpoint6_0Input = {

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

@@ -86,8 +86,6 @@ import type {
   Endpoint5_33Output,
   Endpoint5_34Input,
   Endpoint5_34Output,
-  Endpoint5_35Input,
-  Endpoint5_35Output,
   Endpoint6_0Input,
   Endpoint6_0Output,
   Endpoint7_0Input,
@@ -612,14 +610,6 @@ const Endpoint5_34 = (raw: RawClient["server.session"]) => (input: Endpoint5_34I
     ),
   )
 
-const Endpoint5_35 = (raw: RawClient["server.session"]) => (input: Endpoint5_35Input) =>
-  preserveEffect<Endpoint5_35Output>()(
-    raw["session.environment"]({
-      params: { sessionID: input["sessionID"] },
-      payload: { variables: input["variables"] },
-    }).pipe(Effect.mapError(mapClientError)),
-  )
-
 const adaptGroup5 = (raw: RawClient["server.session"]) => ({
   list: Endpoint5_0(raw),
   create: Endpoint5_1(raw),
@@ -649,7 +639,6 @@ const adaptGroup5 = (raw: RawClient["server.session"]) => ({
   interrupt: Endpoint5_32(raw),
   background: Endpoint5_33(raw),
   message: Endpoint5_34(raw),
-  environment: Endpoint5_35(raw),
 })
 
 const Endpoint6_0 = (raw: RawClient["server.message"]) => (input: Endpoint6_0Input) =>

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

@@ -80,8 +80,6 @@ import type {
   SessionBackgroundOutput,
   SessionMessageInput,
   SessionMessageOutput,
-  SessionEnvironmentInput,
-  SessionEnvironmentOutput,
   MessageListInput,
   MessageListOutput,
   ModelListInput,
@@ -898,18 +896,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
-      environment: (input: SessionEnvironmentInput, requestOptions?: RequestOptions) =>
-        request<SessionEnvironmentOutput>(
-          {
-            method: "PUT",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/environment`,
-            body: { variables: input["variables"] },
-            successStatus: 204,
-            declaredStatuses: [404, 401, 400],
-            empty: true,
-          },
-          requestOptions,
-        ),
     },
     message: {
       list: (input: MessageListInput, requestOptions?: RequestOptions) =>

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

@@ -3936,13 +3936,6 @@ export type SessionMessageInput = {
 
 export type SessionMessageOutput = { data: SessionMessageInfo }["data"]
 
-export type SessionEnvironmentInput = {
-  readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly variables: { readonly variables: { readonly [x: string]: string } }["variables"]
-}
-
-export type SessionEnvironmentOutput = void
-
 export type MessageListInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
   readonly limit?: {

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

@@ -0,0 +1,38 @@
+export * as ConfigImagePlugin from "./image.js"
+
+import { define } from "@opencode-ai/plugin/effect/plugin"
+import { Effect, Stream } from "effect"
+import { Config } from "../../config.js"
+import { Image } from "../../image.js"
+
+export const Plugin = define({
+  id: "opencode.config.image",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Config.Service
+    const image = yield* Image.Service
+    const loaded = { entries: yield* config.entries() }
+    yield* image.transform((draft) => {
+      for (const entry of loaded.entries) {
+        if (entry.type !== "document") continue
+        const configured = entry.info.media?.image
+        if (!configured) continue
+        draft.configure({
+          ...(configured.auto_resize === undefined ? {} : { autoResize: configured.auto_resize }),
+          ...(configured.max_width === undefined ? {} : { maxWidth: configured.max_width }),
+          ...(configured.max_height === undefined ? {} : { maxHeight: configured.max_height }),
+          ...(configured.max_base64_bytes === undefined ? {} : { maxBase64Bytes: configured.max_base64_bytes }),
+        })
+      }
+    })
+    yield* ctx.event.subscribe().pipe(
+      Stream.filter((event) => event.type === "config.updated"),
+      Stream.runForEach(() =>
+        config.entries().pipe(
+          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
+          Effect.andThen(image.reload()),
+        ),
+      ),
+      Effect.forkScoped({ startImmediately: true }),
+    )
+  }),
+})

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

@@ -1,43 +1,10 @@
 import { Effect } from "effect"
-import { sql } from "drizzle-orm"
 import type { DatabaseMigration } from "../migration.js"
 
-const previousV2Marker = "20260730195856_optional_session_title"
-
 const migration: DatabaseMigration.Migration = {
   id: "20260804233008_loose_psylocke",
   up(tx) {
     return Effect.gen(function* () {
-      // This marker identifies the completed pre-split V2 lineage. Its V2 tables
-      // are canonical, so rename them in place instead of replaying the V1 squash.
-      if (yield* tx.get(sql`SELECT id FROM migration WHERE id = ${previousV2Marker}`)) {
-        const v1Only = yield* tx.get(sql`
-          SELECT 1
-          FROM message
-          WHERE NOT EXISTS (
-            SELECT 1 FROM session_message WHERE session_message.session_id = message.session_id
-          )
-          LIMIT 1
-        `)
-        if (v1Only) return yield* Effect.die(new Error("Previous V2 database contains V1-only session history"))
-
-        yield* tx.run(`DROP INDEX IF EXISTS \`session_project_idx\`;`)
-        yield* tx.run(`DROP INDEX IF EXISTS \`session_workspace_idx\`;`)
-        yield* tx.run(`DROP INDEX IF EXISTS \`session_parent_idx\`;`)
-        yield* tx.run(`DROP INDEX IF EXISTS \`session_time_suspended_idx\`;`)
-        yield* tx.run(`ALTER TABLE \`session\` RENAME TO \`session_v2\`;`)
-        yield* tx.run(`CREATE INDEX \`session_v2_project_idx\` ON \`session_v2\` (\`project_id\`);`)
-        yield* tx.run(`CREATE INDEX \`session_v2_workspace_idx\` ON \`session_v2\` (\`workspace_id\`);`)
-        yield* tx.run(`CREATE INDEX \`session_v2_parent_idx\` ON \`session_v2\` (\`parent_id\`);`)
-        yield* tx.run(
-          `CREATE INDEX \`session_v2_time_suspended_idx\` ON \`session_v2\` (\`time_suspended\`) WHERE "session_v2"."time_suspended" is not null;`,
-        )
-        yield* tx.run(`DROP TABLE IF EXISTS \`data_migration\`;`)
-        yield* tx.run(`DROP TABLE IF EXISTS \`session_context_epoch\`;`)
-        yield* tx.run(`DROP TABLE IF EXISTS \`session_input\`;`)
-        return
-      }
-
       yield* tx.run(`
         CREATE TABLE IF NOT EXISTS \`kv\` (
           \`key\` text PRIMARY KEY,

packages/core/src/image.ts

@@ -2,8 +2,8 @@ export * as Image from "./image.js"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Context, Effect, Layer, Schema } from "effect"
-import { Config } from "./config.js"
 import { FileSystem } from "./filesystem.js"
+import { State } from "./state.js"
 
 export class ResizerUnavailableError extends Schema.TaggedErrorClass<ResizerUnavailableError>()(
   "Image.ResizerUnavailableError",
@@ -32,7 +32,18 @@ export class SizeError extends Schema.TaggedErrorClass<SizeError>()("Image.SizeE
   }
 }
 
-export interface Interface {
+export type Limits = {
+  autoResize: boolean
+  maxWidth: number
+  maxHeight: number
+  maxBase64Bytes: number
+}
+
+export type Draft = {
+  configure: (limits: Partial<Limits>) => void
+}
+
+export interface Interface extends State.Transformable<Draft> {
   readonly normalize: (
     resource: string,
     content: FileSystem.Content & { readonly encoding: "base64" },
@@ -47,7 +58,23 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Im
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const config = yield* Config.Service
+    const state = State.create<Limits, Draft>({
+      name: "image",
+      initial: () => ({
+        autoResize: true,
+        maxWidth: 2_000,
+        maxHeight: 2_000,
+        maxBase64Bytes: 5 * 1024 * 1024,
+      }),
+      draft: (draft) => ({
+        configure: (limits) => {
+          if (limits.autoResize !== undefined) draft.autoResize = limits.autoResize
+          if (limits.maxWidth !== undefined) draft.maxWidth = limits.maxWidth
+          if (limits.maxHeight !== undefined) draft.maxHeight = limits.maxHeight
+          if (limits.maxBase64Bytes !== undefined) draft.maxBase64Bytes = limits.maxBase64Bytes
+        },
+      }),
+    })
     const loadAdapter = yield* Effect.cached(
       Effect.tryPromise({
         try: () => import("./image/photon.js"),
@@ -58,22 +85,11 @@ const layer = Layer.effect(
       resource: string,
       content: FileSystem.Content & { readonly encoding: "base64" },
     ) {
-      const image = Object.assign(
-        {},
-        ...(yield* config.entries()).flatMap((entry) =>
-          entry.type === "document" && entry.info.media?.image ? [entry.info.media.image] : [],
-        ),
-      )
       const normalize = yield* loadAdapter
-      return yield* normalize(resource, content, {
-        autoResize: image.auto_resize ?? true,
-        maxWidth: image.max_width ?? 2_000,
-        maxHeight: image.max_height ?? 2_000,
-        maxBase64Bytes: image.max_base64_bytes ?? 5 * 1024 * 1024,
-      })
+      return yield* normalize(resource, content, state.get())
     })
-    return Service.of({ normalize })
+    return Service.of({ transform: state.transform, reload: state.reload, normalize })
   }),
 )
 
-export const node = makeLocationNode({ service: Service, layer, deps: [Config.node] })
+export const node = makeLocationNode({ service: Service, layer, deps: [] })

packages/core/src/instructions/builtins.ts

@@ -33,7 +33,7 @@ const layer = Layer.effect(
                   `  Workspace root folder: ${location.project.directory}`,
                   `  Is directory a git repo: ${location.vcs?.type === "git" ? "yes" : "no"}`,
                   `  Platform: ${process.platform}`,
-                  `  Prefer ${global.tmp} over generic system temporary directories such as /tmp; it is pre-created and approved for external access.`,
+                  `  Use ${global.tmp} for temporary work outside the workspace; it already exists and is pre-approved for external directory access.`,
                   "</env>",
                 ].join("\n"),
               ),

packages/core/src/plugin/internal.ts

@@ -12,6 +12,7 @@ import { Config } from "../config.js"
 import { Credential } from "../credential.js"
 import { ConfigAgentPlugin } from "../config/plugin/agent.js"
 import { ConfigCommandPlugin } from "../config/plugin/command.js"
+import { ConfigImagePlugin } from "../config/plugin/image.js"
 import { ConfigInstructionPlugin } from "../config/plugin/instruction.js"
 import { ConfigProviderPlugin } from "../config/plugin/provider.js"
 import { ConfigPolicyPlugin } from "../config/plugin/policy.js"
@@ -224,6 +225,7 @@ const post = [
   ConfigReferencePlugin.Plugin,
   ConfigAgentPlugin.Plugin,
   ConfigCommandPlugin.Plugin,
+  ConfigImagePlugin.Plugin,
   ConfigSkillPlugin.Plugin,
   ConfigProviderPlugin.Plugin,
   ConfigWebSearchPlugin.Plugin,

packages/core/src/session.ts

@@ -51,7 +51,6 @@ import { Global } from "@opencode-ai/util/global"
 import { Shell as ShellSchema } from "@opencode-ai/schema/shell"
 import { KeyedMutex } from "./effect/keyed-mutex.js"
 import { fileURLToPath } from "url"
-import { SessionEnvironment } from "./session/environment.js"
 
 // get project -> project.locations
 //
@@ -166,10 +165,6 @@ export interface Interface {
     input: ForkInput,
   ) => Effect.Effect<SessionSchema.Info, NotFoundError | MessageNotFoundError | ForkEmptyError>
   readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<SessionSchema.Info, NotFoundError>
-  readonly environment: (input: {
-    readonly sessionID: SessionSchema.ID
-    readonly variables?: SessionEnvironment.Variables
-  }) => Effect.Effect<SessionEnvironment.Variables | undefined, NotFoundError>
   readonly remove: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
   readonly messages: (input: {
     sessionID: SessionSchema.ID
@@ -309,7 +304,6 @@ const layer = Layer.effect(
     const locations = yield* LocationServiceMap.Service
     const fs = yield* FSUtil.Service
     const jobs = yield* Job.Service
-    const environments = yield* SessionEnvironment.Service
     const scope = yield* Scope.Scope
     const activeShells = new Set<SessionSchema.ID>()
     const shellLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
@@ -453,11 +447,6 @@ const layer = Layer.effect(
         if (!session) return yield* new NotFoundError({ sessionID })
         return session
       }),
-      environment: Effect.fn("Session.environment")(function* (input) {
-        yield* result.get(input.sessionID)
-        if (input.variables !== undefined) yield* environments.set(input.sessionID, input.variables)
-        return yield* environments.get(input.sessionID)
-      }),
       remove: Effect.fn("Session.remove")(function* (sessionID) {
         const session = yield* result.get(sessionID)
         yield* execution.interrupt(sessionID)
@@ -465,7 +454,6 @@ const layer = Layer.effect(
         yield* closeTransport(session)
         const children = yield* result.list({ parentID: sessionID })
         yield* Effect.forEach(children.data, (child) => result.remove(child.id), { concurrency: 1, discard: true })
-        yield* environments.clear(sessionID)
         yield* bus.publish(SessionEvent.Deleted, { sessionID })
         yield* bus.remove(sessionID)
       }),
@@ -664,12 +652,7 @@ const layer = Layer.effect(
             const started = yield* Effect.gen(function* () {
               const shell = yield* Shell.Service
               return yield* shell
-                .create({
-                  command: input.command,
-                  cwd: session.location.directory,
-                  timeout: 0,
-                  metadata: { sessionID: input.sessionID },
-                })
+                .create({ command: input.command, cwd: session.location.directory, timeout: 0 })
                 .pipe(Effect.orDie)
             }).pipe(Effect.provide(locations.get(session.location)))
             yield* bus.publish(
@@ -1119,7 +1102,6 @@ export const node = makeGlobalNode({
   layer: layer.pipe(Layer.orDie),
   deps: [
     Job.node,
-    SessionEnvironment.node,
     Database.node,
     Bus.node,
     Project.node,

packages/core/src/session/environment.ts

@@ -1,33 +0,0 @@
-export * as SessionEnvironment from "./environment.js"
-
-import { Context, Effect, Layer } from "effect"
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
-import { SessionSchema } from "./schema.js"
-
-export type Variables = Readonly<Record<string, string>>
-
-export interface Interface {
-  readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<Variables | undefined>
-  readonly set: (sessionID: SessionSchema.ID, variables: Variables) => Effect.Effect<void>
-  readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SessionEnvironment") {}
-
-const layer = Layer.sync(Service, () => {
-  const environments = new Map<SessionSchema.ID, Variables>()
-
-  return Service.of({
-    get: (sessionID) => Effect.sync(() => environments.get(sessionID)),
-    set: (sessionID, variables) =>
-      Effect.sync(() => {
-        environments.set(sessionID, { ...variables })
-      }),
-    clear: (sessionID) =>
-      Effect.sync(() => {
-        environments.delete(sessionID)
-      }),
-  })
-})
-
-export const node = makeGlobalNode({ service: Service, layer, deps: [] })

packages/core/src/shell.ts

@@ -15,8 +15,6 @@ import { Global } from "@opencode-ai/util/global"
 import { ShellSelect } from "./shell/select.js"
 import type { ShellCreateBefore } from "@opencode-ai/plugin/effect/shell"
 import { PluginHooks } from "./plugin/hooks.js"
-import { SessionEnvironment } from "./session/environment.js"
-import { SessionSchema } from "./session/schema.js"
 
 export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Shell.NotFoundError", {
   id: Shell.ID,
@@ -78,7 +76,6 @@ export const layer = (options?: ShellSelect.Options) =>
       const global = yield* Global.Service
       const environment = yield* Environment.Service
       const hooks = yield* PluginHooks.Service
-      const environments = yield* SessionEnvironment.Service
       const context = yield* Effect.context()
       const runFork = Effect.runForkWith(context)
       const sessions = new Map<string, Active>()
@@ -187,18 +184,13 @@ export const layer = (options?: ShellSelect.Options) =>
         input: Shell.CreateInput,
         before?: (input: ShellCreateBefore) => Effect.Effect<void, E, R>,
       ) {
-        const sessionID = input.metadata?.sessionID
-        const sessionEnvironment =
-          location.workspaceID === undefined && Schema.is(SessionSchema.ID)(sessionID)
-            ? yield* environments.get(sessionID)
-            : undefined
         const invocation: ShellCreateBefore = {
           command: input.command,
           cwd: input.cwd ?? location.directory,
           timeout: input.timeout,
           shell: yield* resolve(),
           env: {
-            ...(sessionEnvironment ?? process.env),
+            ...process.env,
             TERM: "xterm-256color",
             OPENCODE_TERMINAL: "1",
           },
@@ -332,7 +324,7 @@ export const layer = (options?: ShellSelect.Options) =>
               runFork(
                 handle.exitCode.pipe(
                   Effect.flatMap((code) => finish("exited", code)),
-                  Effect.catch(() => finish("exited")),
+                  Effect.catch(() => Effect.void),
                 ),
               )
 
@@ -357,15 +349,7 @@ export function configured(options?: ShellSelect.Options) {
   return makeLocationNode({
     service: Service,
     layer: layer(options),
-    deps: [
-      Bus.node,
-      Location.node,
-      Config.node,
-      Global.node,
-      Environment.node,
-      PluginHooks.node,
-      SessionEnvironment.node,
-    ],
+    deps: [Bus.node, Location.node, Config.node, Global.node, Environment.node, PluginHooks.node],
   })
 }
 

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

@@ -0,0 +1,68 @@
+import { describe, expect } from "bun:test"
+import { Bus } from "@opencode-ai/core/bus"
+import { Config } from "@opencode-ai/core/config"
+import { ConfigImagePlugin } from "@opencode-ai/core/config/plugin/image"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { Image } from "@opencode-ai/core/image"
+import { Plugin } from "@opencode-ai/core/plugin"
+import { PluginHost } from "@opencode-ai/core/plugin/host"
+import { Document, Event, Info, type Entry } from "@opencode-ai/schema/config"
+import { Effect, Layer, Schema } from "effect"
+import { testEffect } from "../lib/effect"
+import { PluginTestLayer } from "../plugin/fixture"
+
+const it = testEffect(Layer.merge(PluginTestLayer, AppNodeBuilder.build(Image.node)))
+const decode = Schema.decodeUnknownSync(Info)
+const content = {
+  uri: "file:///pixel.png",
+  content: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
+  encoding: "base64" as const,
+  mime: "image/png",
+}
+
+describe("ConfigImagePlugin.Plugin", () => {
+  it.live("merges image limits and reloads changed config", () =>
+    Effect.gen(function* () {
+      const image = yield* Image.Service
+      const bus = yield* Bus.Service
+      const config = yield* Config.Test
+      const plugins = yield* Plugin.Service
+      yield* ConfigImagePlugin.Plugin.effect(yield* PluginHost.make(plugins))
+
+      expect(yield* limits(image)).toEqual({ maxWidth: 1_200, maxHeight: 900, maxBytes: 1 })
+
+      yield* config.setEntries([document({ auto_resize: false, max_width: 700, max_base64_bytes: 1 })])
+      yield* bus.publish(Event.Updated, {})
+      yield* waitUntil(
+        limits(image).pipe(
+          Effect.map((current) => current.maxWidth === 700 && current.maxHeight === 2_000 && current.maxBytes === 1),
+        ),
+      )
+    }).pipe(
+      Effect.provide(
+        Config.testLayer([
+          document({ auto_resize: false, max_width: 1_200 }),
+          document({ max_height: 900, max_base64_bytes: 1 }),
+        ]),
+      ),
+    ),
+  )
+})
+
+function document(image: NonNullable<typeof Info.Encoded.media>["image"]): Entry {
+  return new Document({ type: "document", info: decode({ media: { image } }) })
+}
+
+const limits = Effect.fnUntraced(function* (image: Image.Interface) {
+  const error = yield* image.normalize("pixel.png", content).pipe(Effect.flip, Effect.orDie)
+  if (error._tag !== "Image.SizeError") return yield* Effect.die(error)
+  return { maxWidth: error.maxWidth, maxHeight: error.maxHeight, maxBytes: error.maxBytes }
+})
+
+const waitUntil = Effect.fnUntraced(function* (condition: Effect.Effect<boolean>) {
+  for (let attempt = 0; attempt < 200; attempt++) {
+    if (yield* condition) return
+    yield* Effect.sleep("10 millis")
+  }
+  yield* Effect.die(new Error("Timed out waiting for image config reload"))
+})

packages/core/test/database-migration.test.ts

@@ -13,10 +13,6 @@ import { tmpdir } from "./fixture/tmpdir"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
 import legacyCredentialsMigration from "@opencode-ai/core/database/migration/20260805200742_import_legacy_credentials"
 import worktreeMigration from "@opencode-ai/core/database/migration/20260812213948_worktree"
-import previousV2Migration from "@opencode-ai/core/database/migration/20260804233008_loose_psylocke"
-import workspaceMigration from "@opencode-ai/core/database/migration/20260808023530_workspace_domain"
-import executionClaimsMigration from "@opencode-ai/core/database/migration/20260811161259_execution_claim_attempts"
-import sessionInboxMigration from "@opencode-ai/core/database/migration/20260812181746_session_inbox"
 import { Global } from "@opencode-ai/util/global"
 
 const run = <A, E>(
@@ -132,142 +128,6 @@ describe("DatabaseMigration", () => {
     )
   })
 
-  test("preserves previous V2 state through the current migration lineage", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(sql`PRAGMA foreign_keys = ON`)
-        yield* db.run(sql`CREATE TABLE migration (id text PRIMARY KEY, time_completed integer NOT NULL)`)
-        yield* db.run(sql`
-          INSERT INTO migration (id, time_completed)
-          VALUES ('20260730195856_optional_session_title', 1)
-        `)
-        yield* db.run(sql`CREATE TABLE project (id text PRIMARY KEY)`)
-        yield* db.run(sql`
-          CREATE TABLE project_directory (
-            project_id text NOT NULL,
-            directory text NOT NULL,
-            type text,
-            strategy text,
-            time_created integer NOT NULL,
-            PRIMARY KEY (project_id, directory)
-          )
-        `)
-        yield* db.run(sql`
-          CREATE TABLE workspace (
-            id text PRIMARY KEY,
-            type text NOT NULL,
-            name text NOT NULL,
-            project_id text NOT NULL,
-            time_used integer NOT NULL
-          )
-        `)
-        yield* db.run(sql`
-          CREATE TABLE session (
-            id text PRIMARY KEY,
-            project_id text NOT NULL REFERENCES project(id) ON DELETE CASCADE,
-            workspace_id text,
-            parent_id text,
-            time_suspended integer
-          )
-        `)
-        yield* db.run(sql`CREATE INDEX session_project_idx ON session (project_id)`)
-        yield* db.run(sql`CREATE INDEX session_workspace_idx ON session (workspace_id)`)
-        yield* db.run(sql`CREATE INDEX session_parent_idx ON session (parent_id)`)
-        yield* db.run(
-          sql`CREATE INDEX session_time_suspended_idx ON session (time_suspended) WHERE "session"."time_suspended" IS NOT NULL`,
-        )
-        yield* db.run(sql`
-          CREATE TABLE session_message (
-            id text PRIMARY KEY,
-            session_id text NOT NULL REFERENCES session(id) ON DELETE CASCADE,
-            data text NOT NULL
-          )
-        `)
-        yield* db.run(sql`CREATE TABLE message (id text PRIMARY KEY, session_id text NOT NULL)`)
-        yield* db.run(sql`
-          CREATE TABLE session_pending (
-            id text PRIMARY KEY,
-            session_id text NOT NULL REFERENCES session(id) ON DELETE CASCADE
-          )
-        `)
-        yield* db.run(sql`CREATE TABLE event_sequence (aggregate_id text PRIMARY KEY, seq integer NOT NULL)`)
-        yield* db.run(sql`
-          CREATE TABLE event (
-            id text PRIMARY KEY,
-            aggregate_id text NOT NULL REFERENCES event_sequence(aggregate_id) ON DELETE CASCADE,
-            seq integer NOT NULL,
-            created integer NOT NULL,
-            type text NOT NULL,
-            data text NOT NULL
-          )
-        `)
-        yield* db.run(sql`CREATE TABLE data_migration (name text PRIMARY KEY)`)
-        yield* db.run(sql`INSERT INTO project VALUES ('project')`)
-        yield* db.run(sql`INSERT INTO project_directory VALUES ('project', '/repo', 'main', NULL, 1)`)
-        yield* db.run(sql`INSERT INTO session VALUES ('session', 'project', NULL, NULL, NULL)`)
-        yield* db.run(sql`INSERT INTO session_message VALUES ('message', 'session', '{"text":"preserved"}')`)
-        yield* db.run(sql`INSERT INTO session_pending VALUES ('pending', 'session')`)
-        yield* db.run(sql`INSERT INTO event_sequence VALUES ('session', 41)`)
-        yield* db.run(sql`INSERT INTO event VALUES ('event', 'session', 41, 1, 'session.text.ended.1', '{}')`)
-
-        yield* DatabaseMigration.applyOnly(db, [
-          previousV2Migration,
-          workspaceMigration,
-          executionClaimsMigration,
-          sessionInboxMigration,
-          worktreeMigration,
-        ])
-
-        expect(yield* db.get(sql`SELECT id, resume_attempts FROM session_v2`)).toEqual({
-          id: "session",
-          resume_attempts: 0,
-        })
-        expect(yield* db.get(sql`SELECT id, data FROM session_message`)).toEqual({
-          id: "message",
-          data: '{"text":"preserved"}',
-        })
-        expect(yield* db.get(sql`SELECT id FROM session_pending`)).toEqual({ id: "pending" })
-        expect(yield* db.get(sql`SELECT seq FROM event_sequence`)).toEqual({ seq: 41 })
-        expect(yield* db.get(sql`SELECT id, seq FROM event`)).toEqual({ id: "event", seq: 41 })
-        expect(
-          yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session'`),
-        ).toBeUndefined()
-        expect(yield* db.get(sql`SELECT directory FROM worktree`)).toEqual({ directory: "/repo" })
-        expect(yield* db.all<{ table: string }>(sql`PRAGMA foreign_key_list(session_message)`)).toContainEqual(
-          expect.objectContaining({ table: "session_v2" }),
-        )
-        expect(yield* db.all<{ table: string }>(sql`PRAGMA foreign_key_list(session_pending)`)).toContainEqual(
-          expect.objectContaining({ table: "session_v2" }),
-        )
-      }),
-    )
-  })
-
-  test("rejects previous V2 databases with V1-only session history", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(sql`CREATE TABLE migration (id text PRIMARY KEY, time_completed integer NOT NULL)`)
-        yield* db.run(sql`
-          INSERT INTO migration (id, time_completed)
-          VALUES ('20260730195856_optional_session_title', 1)
-        `)
-        yield* db.run(sql`CREATE TABLE session (id text PRIMARY KEY)`)
-        yield* db.run(sql`CREATE TABLE session_message (id text PRIMARY KEY, session_id text NOT NULL)`)
-        yield* db.run(sql`CREATE TABLE message (id text PRIMARY KEY, session_id text NOT NULL)`)
-        yield* db.run(sql`INSERT INTO session VALUES ('session')`)
-        yield* db.run(sql`INSERT INTO message VALUES ('message', 'session')`)
-
-        expect((yield* Effect.exit(DatabaseMigration.applyOnly(db, [previousV2Migration])))._tag).toBe("Failure")
-        expect(yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session'`)).toEqual({
-          name: "session",
-        })
-        expect(yield* db.get(sql`SELECT id FROM migration WHERE id = ${previousV2Migration.id}`)).toBeUndefined()
-      }),
-    )
-  })
-
   test("copies project directories into worktrees without removing the old table", async () => {
     await run(
       Effect.gen(function* () {

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

@@ -51,7 +51,7 @@ describe("InstructionBuiltIns", () => {
           `  Workspace root folder: ${projectDirectory}`,
           "  Is directory a git repo: yes",
           `  Platform: ${process.platform}`,
-          `  Prefer ${temporary} over generic system temporary directories such as /tmp; it is pre-created and approved for external access.`,
+          `  Use ${temporary} for temporary work outside the workspace; it already exists and is pre-approved for external directory access.`,
           "</env>",
           "",
           `Today's date: ${localDate(timestamp)}`,

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

@@ -679,18 +679,13 @@ describe("Session.create", () => {
         const created = yield* session.create({
           location: Location.Ref.make({ directory: AbsolutePath.make(directory) }),
         })
-        yield* session.environment({ sessionID: created.id, variables: { OPENCODE_SESSION_ENV_TEST: "attached" } })
 
-        const command =
-          process.platform === "win32"
-            ? "[Console]::Out.Write($env:OPENCODE_SESSION_ENV_TEST)"
-            : 'printf %s "$OPENCODE_SESSION_ENV_TEST"'
-        yield* session.shell({ sessionID: created.id, command })
+        yield* session.shell({ sessionID: created.id, command: "echo hello" })
 
         const messages = yield* session.messages({ sessionID: created.id, order: "asc" })
         const shell = messages.find((message): message is SessionMessage.Shell => message.type === "shell")
-        expect(shell).toMatchObject({ type: "shell", command, status: "exited", exit: 0 })
-        expect(shell?.output?.output).toContain("attached")
+        expect(shell).toMatchObject({ type: "shell", command: "echo hello", status: "exited", exit: 0 })
+        expect(shell?.output?.output).toContain("hello")
         expect(shell?.output?.truncated).toBe(false)
         expect(shell?.time.completed).toBeDefined()
       }),

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

@@ -1,30 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Session } from "@opencode-ai/core/session"
-import { SessionEnvironment } from "@opencode-ai/core/session/environment"
-import { testEffect } from "./lib/effect"
-
-const it = testEffect(AppNodeBuilder.build(SessionEnvironment.node))
-
-describe("SessionEnvironment", () => {
-  it.effect("stores replacement snapshots by session", () =>
-    Effect.gen(function* () {
-      const environments = yield* SessionEnvironment.Service
-      const first = Session.ID.make("ses_environment_first")
-      const second = Session.ID.make("ses_environment_second")
-
-      yield* environments.set(first, { TOOLCHAIN: "first", PATH: "/first/bin" })
-      yield* environments.set(second, { TOOLCHAIN: "second" })
-      yield* environments.set(first, { TOOLCHAIN: "updated" })
-
-      expect(yield* environments.get(first)).toEqual({ TOOLCHAIN: "updated" })
-      expect(yield* environments.get(second)).toEqual({ TOOLCHAIN: "second" })
-
-      yield* environments.clear(first)
-
-      expect(yield* environments.get(first)).toBeUndefined()
-      expect(yield* environments.get(second)).toEqual({ TOOLCHAIN: "second" })
-    }),
-  )
-})

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

@@ -12,7 +12,6 @@ import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionModelTransport } from "@opencode-ai/core/session/model-transport"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionStore } from "@opencode-ai/core/session/store"
-import { SessionEnvironment } from "@opencode-ai/core/session/environment"
 import { LocationServiceMap } from "@opencode-ai/core/location-services"
 import { testEffect } from "./lib/effect"
 import { globalProjectLayer } from "./lib/project"
@@ -33,7 +32,6 @@ const it = testEffect(
       Bus.node,
       SessionProjector.node,
       SessionStore.node,
-      SessionEnvironment.node,
       Session.node,
       LocationServiceMap.node,
     ]),
@@ -52,8 +50,6 @@ describe("Session.remove", () => {
       const session = yield* Session.Service
       const parent = yield* session.create({ location })
       const child = yield* session.create({ parentID: parent.id })
-      yield* session.environment({ sessionID: parent.id, variables: { SESSION_ENV: "parent" } })
-      yield* session.environment({ sessionID: child.id, variables: { SESSION_ENV: "child" } })
       yield* (yield* LocationServiceMap.Service).contextEffect(location)
       closed.length = 0
 
@@ -61,9 +57,6 @@ describe("Session.remove", () => {
 
       expect((yield* session.list()).data).toEqual([])
       expect(closed).toEqual([parent.id, child.id])
-      const environments = yield* SessionEnvironment.Service
-      expect(yield* environments.get(parent.id)).toBeUndefined()
-      expect(yield* environments.get(child.id)).toBeUndefined()
       expect(yield* Effect.result(session.get(parent.id))).toMatchObject({ _tag: "Failure" })
       expect(yield* Effect.result(session.get(child.id))).toMatchObject({ _tag: "Failure" })
     }),

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

@@ -1,9 +1,7 @@
 import { beforeEach, describe, expect } from "bun:test"
 import path from "path"
-import { Effect, Exit, Layer, Stream } from "effect"
+import { Effect, Exit, Layer } from "effect"
 import { Config } from "@opencode-ai/core/config"
-import { Document, Info } from "@opencode-ai/schema/config"
-import { ConfigMedia } from "@opencode-ai/schema/config/media"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FileSystem } from "@opencode-ai/core/filesystem"
@@ -90,7 +88,7 @@ const permission = permissionLayer({
     ),
 })
 const config = Config.testLayer()
-const imageLayer = AppNodeBuilder.build(Image.node, [[Config.node, config]])
+const imageLayer = AppNodeBuilder.build(Image.node)
 const testFileSystem = Layer.effect(
   FSUtil.Service,
   FSUtil.Service.use((fs) =>
@@ -130,10 +128,9 @@ const mutation = Layer.succeed(
     },
   }),
 )
-const unavailableImage = Layer.succeed(
-  Image.Service,
-  Image.Service.of({ normalize: () => Effect.fail(new Image.ResizerUnavailableError()) }),
-)
+const unavailableImage = Layer.mock(Image.Service, {
+  normalize: () => Effect.fail(new Image.ResizerUnavailableError()),
+})
 const readLayer = (imageLayer: Layer.Layer<Image.Service>) =>
   Layer.mergeAll(
     AppNodeBuilder.build(LayerNode.group([Tool.node, readToolNode]), [
@@ -146,8 +143,9 @@ const readLayer = (imageLayer: Layer.Layer<Image.Service>) =>
       [Location.node, locationLayer],
       [Global.node, Global.layerWith({ data: Global.Path.data })],
     ]),
-    // Merge by reference so Config.Test resolves to the memoized instance.
+    // Merge by reference so Config.Test and Image.Service resolve to the memoized instances.
     config,
+    imageLayer,
   )
 const it = testEffect(readLayer(imageLayer))
 const itWithoutResizer = testEffect(readLayer(unavailableImage))
@@ -384,17 +382,8 @@ describe("ReadTool", () => {
         encoding: "base64",
         mime: "image/png",
       }
-      const configTest = yield* Config.Test
-      yield* configTest.setEntries([
-        new Document({
-          type: "document",
-          info: new Info({
-            media: new ConfigMedia.Info({
-              image: new ConfigMedia.Image({ auto_resize: false, max_width: 4 }),
-            }),
-          }),
-        }),
-      ])
+      const image = yield* Image.Service
+      yield* image.transform((draft) => draft.configure({ autoResize: false, maxWidth: 4 }))
       const registry = yield* Tool.Service
 
       expect(
@@ -427,15 +416,8 @@ describe("ReadTool", () => {
         encoding: "base64",
         mime: "image/png",
       }
-      const configTest = yield* Config.Test
-      yield* configTest.setEntries([
-        new Document({
-          type: "document",
-          info: new Info({
-            media: new ConfigMedia.Info({ image: new ConfigMedia.Image({ max_width: 4 }) }),
-          }),
-        }),
-      ])
+      const image = yield* Image.Service
+      yield* image.transform((draft) => draft.configure({ maxWidth: 4 }))
       const registry = yield* Tool.Service
       const result = yield* executeTool(registry, {
         sessionID,
@@ -466,17 +448,8 @@ describe("ReadTool", () => {
         encoding: "base64",
         mime: "image/png",
       }
-      const configTest = yield* Config.Test
-      yield* configTest.setEntries([
-        new Document({
-          type: "document",
-          info: new Info({
-            media: new ConfigMedia.Info({
-              image: new ConfigMedia.Image({ max_base64_bytes: 1 }),
-            }),
-          }),
-        }),
-      ])
+      const image = yield* Image.Service
+      yield* image.transform((draft) => draft.configure({ maxBase64Bytes: 1 }))
       const registry = yield* Tool.Service
 
       expect(

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

@@ -260,36 +260,6 @@ describe("ShellTool", () => {
     { timeout: 15_000 },
   )
 
-  productionIt.live(
-    "uses the session environment instead of the server environment",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => {
-          reset()
-          return withSession(tmp.path, (registry) =>
-            Effect.gen(function* () {
-              const sessions = yield* Session.Service
-              yield* sessions.environment({
-                sessionID,
-                variables: { OPENCODE_SESSION_ENV_TEST: "from-session" },
-              })
-              const command = isWindows
-                ? "[Console]::Out.Write($env:OPENCODE_SESSION_ENV_TEST)"
-                : 'printf %s "$OPENCODE_SESSION_ENV_TEST"'
-
-              const settled = yield* executeTool(registry, call({ command }))
-
-              expect(settled.status).toBe("completed")
-              expect(settled.content?.[0]).toEqual({ type: "text", text: "from-session" })
-            }),
-          )
-        },
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
-      ),
-    { timeout: 15_000 },
-  )
-
   it.live("resolves a relative workdir from the active Location", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),
@@ -812,40 +782,6 @@ describe("ShellTool", () => {
     ),
   )
 
-  if (!isWindows) {
-    it.live("settles a shell terminated by an external signal", () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => {
-          reset()
-          return withSession(tmp.path, (registry) =>
-            Effect.gen(function* () {
-              const shell = yield* Shell.Service
-              const settled = yield* executeTool(
-                registry,
-                call({ command: idleCommand, background: true }, "call-external-signal"),
-              )
-              const shellID = settled.metadata?.shellID
-              expect(typeof shellID).toBe("string")
-              if (typeof shellID !== "string") return
-              const id = ShellSchema.ID.make(shellID)
-              const info = yield* shell.get(id)
-              expect(typeof info.pid).toBe("number")
-              if (info.pid === undefined) return
-
-              process.kill(-info.pid, "SIGTERM")
-              const result = yield* shell.wait(id).pipe(Effect.timeoutOption(Duration.seconds(1)))
-              expect(result._tag).toBe("Some")
-              if (result._tag === "Some") expect(result.value.status).toBe("exited")
-              expect((yield* shell.list()).map((item) => item.id)).not.toContain(id)
-            }),
-          )
-        },
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
-      ),
-    )
-  }
-
   it.live("backgrounds a foreground command when the session is signaled", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),

packages/protocol/openapi.json

@@ -4127,85 +4127,6 @@
         "summary": "Get session message"
       }
     },
-    "/api/session/{sessionID}/environment": {
-      "put": {
-        "tags": ["session"],
-        "operationId": "v2.session.environment",
-        "parameters": [
-          {
-            "name": "sessionID",
-            "in": "path",
-            "schema": {
-              "type": "string",
-              "allOf": [
-                {
-                  "pattern": "^ses"
-                }
-              ]
-            },
-            "required": true
-          }
-        ],
-        "security": [],
-        "responses": {
-          "204": {
-            "description": "<No Content>"
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          },
-          "404": {
-            "description": "SessionNotFoundError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionNotFoundError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Replace the process environment used by local shell commands for this session.",
-        "summary": "Set session environment",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "type": "object",
-                "properties": {
-                  "variables": {
-                    "type": "object",
-                    "additionalProperties": {
-                      "type": "string"
-                    }
-                  }
-                },
-                "required": ["variables"],
-                "additionalProperties": false
-              }
-            }
-          },
-          "required": true
-        }
-      }
-    },
     "/api/session/{sessionID}/message": {
       "get": {
         "tags": ["session"],

packages/protocol/src/groups/session.ts

@@ -693,20 +693,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         }),
       ),
     )
-    .add(
-      HttpApiEndpoint.put("session.environment", "/api/session/:sessionID/environment", {
-        params: { sessionID: Session.ID },
-        payload: Schema.Struct({ variables: Schema.Record(Schema.String, Schema.String) }),
-        success: HttpApiSchema.NoContent,
-        error: SessionNotFoundError,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.session.environment",
-          summary: "Set session environment",
-          description: "Replace the process environment used by local shell commands for this session.",
-        }),
-      ),
-    )
     .annotateMerge(
       OpenApi.annotations({
         title: "session",

packages/server/src/handlers/session.ts

@@ -196,22 +196,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           return HttpApiSchema.NoContent.make()
         }),
       )
-      .handle(
-        "session.environment",
-        Effect.fn(function* (ctx) {
-          yield* session.environment({ sessionID: ctx.params.sessionID, variables: ctx.payload.variables }).pipe(
-            Effect.catchTag(
-              "Session.NotFoundError",
-              (error) =>
-                new SessionNotFoundError({
-                  sessionID: error.sessionID,
-                  message: `Session not found: ${error.sessionID}`,
-                }),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
       .handle(
         "session.fork",
         Effect.fn(function* (ctx) {

packages/stats/app/src/routes/model-catalog.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-
-mock.module("@solidjs/router", () => ({ query: (load: () => unknown) => load }))
-
-const { buildModelCatalog, findModelCatalogEntry } = await import("./model-catalog")
-
-describe("model catalog pricing", () => {
-  test("prefers OpenCode Go pricing over a zero-cost coding plan with the same model id", () => {
-    const catalog = buildModelCatalog(
-      {
-        models: {
-          "zhipuai/glm-5.3": {
-            id: "zhipuai/glm-5.3",
-            name: "GLM-5.3",
-          },
-        },
-      },
-      {
-        "opencode-go": {
-          id: "opencode-go",
-          models: {
-            "glm-5.3": {
-              id: "glm-5.3",
-              cost: { input: 1.4, output: 4.4, cache_read: 0.26 },
-            },
-          },
-        },
-        "zhipuai-coding-plan": {
-          id: "zhipuai-coding-plan",
-          models: {
-            "glm-5.3": {
-              id: "glm-5.3",
-              cost: { input: 0, output: 0, cache_read: 0 },
-            },
-          },
-        },
-      },
-    )
-
-    expect(findModelCatalogEntry(catalog, "glm-5.3")?.cost).toEqual({
-      input: 1.4,
-      output: 4.4,
-      cacheRead: 0.26,
-      cacheWrite: undefined,
-    })
-  })
-})

packages/stats/app/src/routes/model-catalog.ts

@@ -119,7 +119,7 @@ export function catalogSlug(value: string) {
     .replace(/-{2,}/g, "-")
 }
 
-export function buildModelCatalog(payload: unknown, pricingPayload?: unknown, labPayload?: unknown): ModelCatalog {
+function buildModelCatalog(payload: unknown, pricingPayload?: unknown, labPayload?: unknown): ModelCatalog {
   const costs = readCatalogCosts(pricingPayload)
   const labDescriptions = readCatalogLabDescriptions(payload, pricingPayload, labPayload)
   const models = readCatalogModels(payload)
@@ -129,7 +129,6 @@ export function buildModelCatalog(payload: unknown, pricingPayload?: unknown, la
       cost:
         costs.get(catalogIdKey(model.id)) ??
         costs.get(`${model.lab}/${model.slug}`) ??
-        costs.get(`opencode-go/${model.slug}`) ??
         costs.get(model.slug) ??
         model.cost,
     }))

packages/tui/src/app.tsx

@@ -41,7 +41,6 @@ import {
   useTuiApp,
   useTuiPaths,
   useTuiStartup,
-  useTuiTerminalEnvironment,
   type TuiApp,
 } from "./context/runtime"
 import { DialogProvider, useDialog } from "./ui/dialog"
@@ -186,7 +185,6 @@ export type TuiInput = {
   args: Args
   config: Config.Interface
   packages: PackageResolver
-  environment?: Readonly<Record<string, string>>
   terminalHandoff?: () => Promise<
     | {
         readonly renderer: CliRenderer
@@ -334,7 +332,6 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
                                   : process.env.DISPLAY
                                     ? "x11"
                                     : undefined,
-                                variables: input.environment,
                               }}
                             >
                               <TuiStartupProvider
@@ -483,17 +480,6 @@ function App(props: { pair?: DialogPairCredentials }) {
   const promptRef = usePromptRef()
   const plugins = usePlugin()
   const clipboard = useClipboard()
-  const terminalEnvironment = useTuiTerminalEnvironment()
-  createEffect(() => {
-    if (client.connection.status() !== "connected") return
-    if (route.data.type !== "session") return
-    const session = data.session.get(route.data.sessionID)
-    if (!session) return
-    if (session.location.workspaceID !== undefined || terminalEnvironment.variables === undefined) return
-    void client.api.session
-      .environment({ sessionID: session.id, variables: terminalEnvironment.variables })
-      .catch(toast.error)
-  })
   const [layout, updateLayout] = useStorage().store<{ verticalTabsWidth?: number }>("layout", {
     initial: { verticalTabsWidth: SESSION_SIDEBAR_WIDTH },
   })

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

@@ -452,6 +452,7 @@ export function Prompt(props: PromptProps) {
         title: "Queue prompt",
         name: "prompt.queue",
         category: "Prompt",
+        palette: undefined,
         run: async (_input: string | undefined, event?: KeyEvent) => {
           event?.preventDefault()
           event?.stopPropagation()
@@ -1205,19 +1206,6 @@ export function Prompt(props: PromptProps) {
 
       sessionID = created.id
       session = created
-      if (created.location.workspaceID === undefined && terminalEnvironment.variables !== undefined) {
-        const error = await client.api.session
-          .environment({ sessionID, variables: terminalEnvironment.variables })
-          .then(
-            () => undefined,
-            (error) => error,
-          )
-        if (error) {
-          if (finishMoveProgress) move.finishSubmit()
-          toast.show({ title: "Failed to set session environment", message: errorMessage(error), variant: "error" })
-          return true
-        }
-      }
     }
 
     // Capture mode before it gets reset

packages/tui/src/config/keybind.ts

@@ -178,7 +178,7 @@ export const Definitions = {
   "session.toggle.thinking": keybind("none", "Toggle thinking blocks visibility"),
 
   "prompt.submit": keybind("none", "Submit prompt"),
-  "prompt.queue": keybind("<leader>return", "Queue prompt"),
+  "prompt.queue": keybind("alt+return", "Queue prompt"),
   "prompt.editor_context.clear": keybind("none", "Clear editor context"),
   "prompt.images.view": keybind("<leader>i", "View image attachments"),
   "prompt.skills": keybind("none", "Open skill selector"),

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

@@ -163,7 +163,7 @@ export const Definitions = {
   display_thinking: keybind("none", "Toggle thinking blocks visibility"),
 
   prompt_submit: keybind("none", "Submit prompt"),
-  prompt_queue: keybind("<leader>return", "Queue prompt"),
+  prompt_queue: keybind("alt+return", "Queue prompt"),
   prompt_editor_context_clear: keybind("none", "Clear editor context"),
   prompt_images_view: keybind("<leader>i", "View image attachments"),
   prompt_skills: keybind("none", "Open skill selector"),

packages/tui/src/context/runtime.tsx

@@ -17,7 +17,6 @@ export type TuiTerminalEnvironment = Readonly<{
   platform: string
   multiplexer?: "tmux" | "screen"
   displayServer?: "wayland" | "x11"
-  variables?: Readonly<Record<string, string>>
 }>
 
 export type TuiStartup = Readonly<{

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

@@ -1050,7 +1050,6 @@ export function createPromptState(input: PromptInput): PromptState {
         id: "prompt.queue",
         title: "Queue prompt",
         group: "Prompt",
-        palette: true,
         run() {
           syncDraft()
           submitPrompt(promptCopy(draft), "queue")

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

@@ -595,7 +595,7 @@ export function RunFooterView(props: RunFooterViewProps) {
       {
         id: "session.queued_prompts",
         title: "View queued prompts",
-        group: "Prompt",
+        group: "Session",
         run: openQueuedMenu,
       },
     ],

packages/tui/src/routes/session/index.tsx

@@ -1062,7 +1062,7 @@ export function Session(props: { verticalTabsWidth: number }) {
     {
       title: "View queued prompts",
       id: "session.queued_prompts",
-      group: "Prompt",
+      group: "Session",
       enabled: queuedPrompts().length > 0,
       run: openQueuedPrompts,
     },

packages/tui/test/config-v2.test.tsx

@@ -107,7 +107,6 @@ test("preserves migrated v1 keybind defaults", () => {
   const pairs = [
     ["app.exit", "app_exit"],
     ["prompt.paste", "input_paste"],
-    ["prompt.queue", "prompt_queue"],
     ["session.delete", "session_delete"],
     ["session.list", "session_list"],
     ["agent.list", "agent_list"],

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

@@ -981,8 +981,7 @@ test("direct footer steers the oldest queued prompt from an empty composer", asy
 
   try {
     await app.renderOnce()
-    app.mockInput.pressKey("x", { ctrl: true })
-    app.mockInput.pressEnter()
+    app.mockInput.pressEnter({ meta: true })
     await Bun.sleep(0)
     expect(steered).toEqual([])
     app.mockInput.pressEnter()
@@ -1035,8 +1034,7 @@ test("direct footer rejects local commands submitted with the queue shortcut", a
   try {
     await app.renderOnce()
     await app.mockInput.typeText("/settings ")
-    app.mockInput.pressKey("x", { ctrl: true })
-    app.mockInput.pressEnter()
+    app.mockInput.pressEnter({ meta: true })
     await Bun.sleep(0)
     expect(submitted).toEqual([])
     expect(statuses).toContain("this prompt cannot be queued")

packages/tui/test/mini/runtime.boot.test.ts

@@ -22,7 +22,7 @@ describe("run runtime boot", () => {
     expect(result.keybinds.get("prompt.clear")?.[0]?.key).toBe("ctrl+c")
     expect(result.keybinds.get("input.submit")?.[0]?.key).toBe("return")
     expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("shift+return,ctrl+return,ctrl+j")
-    expect(result.keybinds.get("prompt.queue")?.[0]?.key).toBe("<leader>return")
+    expect(result.keybinds.get("prompt.queue")?.[0]?.key).toBe("alt+return")
   })
 
   test("preserves shared config while resolving independent Mini defaults", async () => {

packages/www/openapi.json

@@ -4127,85 +4127,6 @@
         "summary": "Get session message"
       }
     },
-    "/api/session/{sessionID}/environment": {
-      "put": {
-        "tags": ["session"],
-        "operationId": "v2.session.environment",
-        "parameters": [
-          {
-            "name": "sessionID",
-            "in": "path",
-            "schema": {
-              "type": "string",
-              "allOf": [
-                {
-                  "pattern": "^ses"
-                }
-              ]
-            },
-            "required": true
-          }
-        ],
-        "security": [],
-        "responses": {
-          "204": {
-            "description": "<No Content>"
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          },
-          "404": {
-            "description": "SessionNotFoundError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionNotFoundError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Replace the process environment used by local shell commands for this session.",
-        "summary": "Set session environment",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "type": "object",
-                "properties": {
-                  "variables": {
-                    "type": "object",
-                    "additionalProperties": {
-                      "type": "string"
-                    }
-                  }
-                },
-                "required": ["variables"],
-                "additionalProperties": false
-              }
-            }
-          },
-          "required": true
-        }
-      }
-    },
     "/api/session/{sessionID}/message": {
       "get": {
         "tags": ["session"],

packages/www/public/openapi.json

@@ -4127,85 +4127,6 @@
         "summary": "Get session message"
       }
     },
-    "/api/session/{sessionID}/environment": {
-      "put": {
-        "tags": ["session"],
-        "operationId": "v2.session.environment",
-        "parameters": [
-          {
-            "name": "sessionID",
-            "in": "path",
-            "schema": {
-              "type": "string",
-              "allOf": [
-                {
-                  "pattern": "^ses"
-                }
-              ]
-            },
-            "required": true
-          }
-        ],
-        "security": [],
-        "responses": {
-          "204": {
-            "description": "<No Content>"
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          },
-          "404": {
-            "description": "SessionNotFoundError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionNotFoundError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Replace the process environment used by local shell commands for this session.",
-        "summary": "Set session environment",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "type": "object",
-                "properties": {
-                  "variables": {
-                    "type": "object",
-                    "additionalProperties": {
-                      "type": "string"
-                    }
-                  }
-                },
-                "required": ["variables"],
-                "additionalProperties": false
-              }
-            }
-          },
-          "required": true
-        }
-      }
-    },
     "/api/session/{sessionID}/message": {
       "get": {
         "tags": ["session"],