refactor(cli): centralize session environment sync

Co-authored-by: Luke Parker <10430890+Hona@users.noreply.github.com>

.github/workflows/publish.yml

@@ -466,6 +466,7 @@ jobs:
           VITE_SENTRY_ENVIRONMENT: ${{ (github.ref_name == 'beta' && 'beta') || 'production' }}
           VITE_SENTRY_RELEASE: desktop@${{ needs.version.outputs.version }}
           OPENCODE_CLI_TARGET: ${{ matrix.settings.target }}
+          OPENCODE_CLI_DIST: ${{ github.workspace }}/packages/cli/dist
 
       - name: Package
         if: needs.version.outputs.release

packages/app/src/pages/new-session/new-session-view.tsx

@@ -60,7 +60,11 @@ export function NewSessionView(props: {
                   <Show
                     when={props.workspace.bar.visible()}
                     fallback={
-                      <PromptGitStatus branch={props.workspace.bar.branch()} noGit={!props.workspace.project.git()} />
+                      <PromptGitStatus
+                        branch={props.workspace.bar.branch()}
+                        noGit={!props.workspace.project.git()}
+                        class="ms-1"
+                      />
                     }
                   >
                     <PromptWorkspaceSelector

packages/cli/bin/opencode2.cjs

@@ -5,7 +5,8 @@ const fs = require("fs")
 const path = require("path")
 const os = require("os")
 
-const forwardedSignals = ["SIGINT", "SIGTERM", "SIGHUP"]
+const forwardedSignals =
+  process.platform === "win32" ? ["SIGINT", "SIGTERM", "SIGHUP"] : ["SIGINT", "SIGTERM", "SIGHUP", "SIGUSR1"]
 
 function run(target) {
   const child = childProcess.spawn(target, process.argv.slice(2), { stdio: "inherit" })

packages/cli/script/build.ts

@@ -117,9 +117,9 @@ for (const item of targets) {
       autoloadTsconfig: true,
       autoloadPackageJson: true,
       target: target.replace(binary, "bun") as Bun.Build.CompileTarget,
-      executablePath,
+      ...(executablePath ? { executablePath } : {}),
       outfile: path.join(outdir, name, "bin", binary),
-      execArgv: [`--user-agent=${binary}/${Script.version}`, "--use-system-ca", "--"],
+      execArgv: [`--user-agent=${binary}/${Script.version}`, "--use-system-ca", "--no-warnings", "--"],
       windows: {},
     },
     define: {

packages/cli/script/publish.ts

@@ -20,7 +20,6 @@ async function publish(dir: string, name: string, version: string) {
     await $`bun pm pack`.cwd(dir)
     await $`npm publish *.tgz --access public --tag ${Script.channel}`.cwd(dir)
   }
-  if (Script.channel === "beta") await $`npm dist-tag add ${`${name}@${version}`} next`
 }
 
 async function publishDistribution(input: { root: string; name: string; binary: string; packagePrefix: string }) {

packages/cli/src/commands/commands.ts

@@ -1,5 +1,6 @@
-import { Argument, Flag } from "effect/unstable/cli"
+import { Argument, Command, Flag } from "effect/unstable/cli"
 import { Spec } from "../framework/spec"
+import { GlobalFlags } from "./global-flags"
 
 declare const OPENCODE_CLI_NAME: string | undefined
 
@@ -26,7 +27,7 @@ const PermissionParams = {
   ),
 }
 
-export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME : "opencode", {
+const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME : "opencode", {
   description: "OpenCode 2.0 preview command line interface",
   params: {
     ...ServerParams,
@@ -70,7 +71,7 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
       description: "Debugging and troubleshooting tools",
       commands: [
         Spec.make("agents", { description: "List all agents" }),
-        Spec.make("config", { description: "Show resolved configuration" }),
+        Spec.make("config", { description: "List configuration sources" }),
       ],
     }),
     Spec.make("console", {
@@ -277,3 +278,5 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
     }),
   ],
 })
+
+export const Commands = { ...Root, spec: Root.spec.pipe(Command.withGlobalFlags(GlobalFlags.all)) }

packages/cli/src/commands/global-flags.ts

@@ -0,0 +1,12 @@
+export * as GlobalFlags from "./global-flags"
+
+import { Flag, GlobalFlag } from "effect/unstable/cli"
+
+export const CpuProfile = GlobalFlag.setting("cpu-profile")({
+  flag: Flag.string("cpu-profile").pipe(
+    Flag.withDescription("Write a CPU profile to this path when the process stops"),
+    Flag.optional,
+  ),
+})
+
+export const all = [CpuProfile] as const

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

@@ -10,15 +10,17 @@ 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: Option.getOrUndefined(input.server),
+      server: requestedServer,
       standalone: input.standalone,
       mismatch: "replace",
       onStart: (reason, previousVersion) => {
@@ -75,6 +77,7 @@ 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/cpu-profile.ts

@@ -0,0 +1,45 @@
+export * as CpuProfile from "./cpu-profile"
+
+import { Effect, FileSystem } from "effect"
+import { Session } from "node:inspector"
+import path from "node:path"
+
+export function run<A, E, R>(file: string, effect: Effect.Effect<A, E, R>) {
+  const target = path.resolve(file)
+  return Effect.acquireUseRelease(
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem
+      yield* fs.makeDirectory(path.dirname(target), { recursive: true })
+      const session = new Session()
+      session.connect()
+      yield* command(session, "Profiler.enable")
+      yield* command(session, "Profiler.start")
+      yield* Effect.logInfo("CPU profile started", { path: target })
+      return session
+    }),
+    () => effect,
+    (session) =>
+      Effect.tryPromise(
+        () =>
+          new Promise<void>((resolve, reject) => {
+            session.post("Profiler.stop", (error, result) => {
+              session.disconnect()
+              if (error) return reject(error)
+              Bun.write(target, JSON.stringify(result.profile)).then(() => resolve(), reject)
+            })
+          }),
+      ).pipe(
+        Effect.andThen(Effect.logInfo("CPU profile written", { path: target })),
+        Effect.catchCause((cause) => Effect.logError("Failed to write CPU profile", { path: target, cause })),
+      ),
+  )
+}
+
+function command(session: Session, method: "Profiler.enable" | "Profiler.start") {
+  return Effect.tryPromise(
+    () =>
+      new Promise<void>((resolve, reject) => {
+        session.post(method, (error) => (error ? reject(error) : resolve()))
+      }),
+  )
+}

packages/cli/src/env.ts

@@ -12,4 +12,13 @@ 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/framework/runtime.ts

@@ -1,10 +1,13 @@
-import { Effect, FileSystem, Scope } from "effect"
+import { Effect, FileSystem, Option, Scope } from "effect"
 import { Command } from "effect/unstable/cli"
 import { Spec } from "./spec"
 import { Global } from "@opencode-ai/util/global"
 import { Updater } from "../services/updater"
 import { Config } from "../config"
 import { Npm } from "@opencode-ai/util/npm"
+import { GlobalFlags } from "../commands/global-flags"
+import { CpuProfile } from "../cpu-profile"
+import path from "node:path"
 
 export type Input<Value> =
   Value extends Spec.Node<infer _Name, infer Command, infer _Commands>
@@ -86,7 +89,22 @@ function provide(node: Spec.Any, handlers: ReadonlyArray<LazyHandler>): Provided
     ? node.spec.pipe(
         Command.withHandler((input) =>
           Effect.gen(function* () {
-            yield* Effect.flatMap(Effect.promise(handler.load), (module) => module.default(input))
+            const module = yield* Effect.promise(handler.load)
+            const cpuProfile = Option.getOrUndefined(yield* GlobalFlags.CpuProfile)
+            if (!cpuProfile) return yield* module.default(input)
+            const target = path.resolve(cpuProfile)
+            const previous = process.env.OPENCODE_CPU_PROFILE
+            process.env.OPENCODE_CPU_PROFILE = target
+            return yield* (
+              node.name === "serve" ? CpuProfile.run(target, module.default(input)) : module.default(input)
+            ).pipe(
+              Effect.ensuring(
+                Effect.sync(() => {
+                  if (previous === undefined) delete process.env.OPENCODE_CPU_PROFILE
+                  else process.env.OPENCODE_CPU_PROFILE = previous
+                }),
+              ),
+            )
           }),
         ),
       )

packages/cli/src/heap.ts

@@ -0,0 +1,37 @@
+import { Global } from "@opencode-ai/util/global"
+import { Effect, Queue } from "effect"
+import path from "node:path"
+
+export const listen = Effect.gen(function* () {
+  const global = yield* Global.Service
+  if (process.platform === "win32") return
+  const signals = yield* Queue.dropping<void>(1)
+  yield* Effect.acquireRelease(
+    Effect.sync(() => {
+      const handler = () => Queue.offerUnsafe(signals, undefined)
+      process.on("SIGUSR1", handler)
+      return handler
+    }),
+    (handler) => Effect.sync(() => process.off("SIGUSR1", handler)),
+  )
+  yield* Queue.take(signals).pipe(
+    Effect.andThen(
+      Effect.suspend(() => {
+        const file = path.join(
+          global.log,
+          `heap-${process.pid}-${new Date().toISOString().replace(/[:.]/g, "")}.heapsnapshot`,
+        )
+        return Effect.gen(function* () {
+          yield* Effect.logInfo("writing heap snapshot", { path: file })
+          const { writeHeapSnapshot } = yield* Effect.tryPromise(() => import("node:v8"))
+          yield* Effect.try(() => writeHeapSnapshot(file))
+          yield* Effect.logInfo("heap snapshot written", { path: file })
+        }).pipe(Effect.catchCause((cause) => Effect.logError("failed to write heap snapshot", { path: file, cause })))
+      }),
+    ),
+    Effect.forever,
+    Effect.forkScoped({ startImmediately: true }),
+  )
+})
+
+export * as Heap from "./heap"

packages/cli/src/index.ts

@@ -12,6 +12,7 @@ import { Global } from "@opencode-ai/util/global"
 import { AppProcess } from "@opencode-ai/util/process"
 import { Config } from "./config"
 import { Npm } from "@opencode-ai/util/npm"
+import { Heap } from "./heap"
 
 const Handlers = Runtime.handlers(Commands, {
   $: () => import("./commands/handlers/default"),
@@ -54,13 +55,16 @@ const Handlers = Runtime.handlers(Commands, {
   serve: () => import("./commands/handlers/serve"),
 })
 
-Effect.logInfo("cli starting", {
-  version: OPENCODE_VERSION,
-  channel: OPENCODE_CHANNEL,
-  local: OPENCODE_LOCAL,
-  args: process.argv.slice(2),
+Effect.gen(function* () {
+  yield* Heap.listen
+  yield* Effect.logInfo("cli starting", {
+    version: OPENCODE_VERSION,
+    channel: OPENCODE_CHANNEL,
+    local: OPENCODE_LOCAL,
+    args: process.argv.slice(2),
+  })
+  return yield* Runtime.run(Commands, Handlers, { version: OPENCODE_VERSION })
 }).pipe(
-  Effect.flatMap(() => Runtime.run(Commands, Handlers, { version: OPENCODE_VERSION })),
   Effect.annotateLogs({ role: "cli" }),
   Effect.provide(Config.layer),
   Effect.provide(Updater.layer),

packages/cli/src/mini.ts

@@ -5,6 +5,7 @@ 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: {
@@ -38,6 +39,7 @@ 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)
@@ -55,6 +57,7 @@ export async function runMini(input: MiniCommandInput) {
               fork: input.fork,
               model: requested,
               agent: input.agent,
+              environment,
               prepare,
               signal,
             }).catch((error) => {
@@ -89,6 +92,7 @@ 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,6 +9,7 @@ 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
@@ -91,6 +92,7 @@ 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/services/service-config.ts

@@ -104,7 +104,12 @@ export const options = Effect.fnUntraced(function* (input: { readonly checkVersi
   return {
     file,
     version: input.checkVersion ? OPENCODE_VERSION : undefined,
-    command: [...selfCommand(), "serve", "--service"],
+    command: [
+      ...selfCommand(),
+      "serve",
+      "--service",
+      ...(process.env.OPENCODE_CPU_PROFILE ? ["--cpu-profile", process.env.OPENCODE_CPU_PROFILE] : []),
+    ],
   }
 })
 

packages/cli/src/session-target.ts

@@ -36,6 +36,7 @@ export async function resolveSessionTarget(input: {
   fork?: boolean
   model?: ModelRef
   agent?: string
+  environment?: Readonly<Record<string, string>>
   prepare: SessionTargetPreparation
   signal?: AbortSignal
 }): Promise<SessionTarget> {
@@ -70,6 +71,12 @@ 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/test/debug-config.test.ts

@@ -10,9 +10,10 @@ describe("debug config command", () => {
 
     expect(debug.exitCode).toBe(0)
     expect(debug.stdout).toContain("config")
-    expect(debug.stdout).toContain("Show resolved configuration")
+    expect(debug.stdout).toContain("List configuration sources")
     expect(config.exitCode).toBe(0)
     expect(config.stdout).toContain("opencode debug config [flags]")
+    expect(config.stdout).toContain("List configuration sources")
   })
 
   test("prints config entries from the invoking directory without reordering permissions", async () => {

packages/cli/test/env.test.ts

@@ -0,0 +1,24 @@
+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/service.test.ts

@@ -19,6 +19,29 @@ test("managed service ports are stable per installation channel", () => {
   expect(ServiceConfig.defaultPort("preview-a")).not.toBe(ServiceConfig.defaultPort("preview-b"))
 })
 
+test("managed service forwards the CPU profile path to the server", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-profile-"))
+  const profile = path.join(root, "server.cpuprofile")
+  try {
+    const previous = process.env.OPENCODE_CPU_PROFILE
+    process.env.OPENCODE_CPU_PROFILE = profile
+    try {
+      const options = await Effect.runPromise(
+        ServiceConfig.options().pipe(
+          Effect.provide(Global.layerWith({ config: path.join(root, "config"), state: path.join(root, "state") })),
+          Effect.provide(NodeFileSystem.layer),
+        ),
+      )
+      expect(options.command.slice(-2)).toEqual(["--cpu-profile", profile])
+    } finally {
+      if (previous === undefined) delete process.env.OPENCODE_CPU_PROFILE
+      else process.env.OPENCODE_CPU_PROFILE = previous
+    }
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
 test("local channel stores service config with the local service filename", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-"))
   try {

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

@@ -55,6 +55,26 @@ 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,6 +914,10 @@ 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>
@@ -958,6 +962,7 @@ 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,6 +86,8 @@ import type {
   Endpoint5_33Output,
   Endpoint5_34Input,
   Endpoint5_34Output,
+  Endpoint5_35Input,
+  Endpoint5_35Output,
   Endpoint6_0Input,
   Endpoint6_0Output,
   Endpoint7_0Input,
@@ -610,6 +612,14 @@ 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),
@@ -639,6 +649,7 @@ 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,6 +80,8 @@ import type {
   SessionBackgroundOutput,
   SessionMessageInput,
   SessionMessageOutput,
+  SessionEnvironmentInput,
+  SessionEnvironmentOutput,
   MessageListInput,
   MessageListOutput,
   ModelListInput,
@@ -896,6 +898,18 @@ 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,6 +3936,13 @@ 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/plugin/provider.ts

@@ -16,7 +16,6 @@ import { GroqPlugin } from "./provider/groq.js"
 import { KiloPlugin } from "./provider/kilo.js"
 import { LLMGatewayPlugin } from "./provider/llmgateway.js"
 import { MistralPlugin } from "./provider/mistral.js"
-import { ModalPlugin } from "./provider/modal.js"
 import { NvidiaPlugin } from "./provider/nvidia.js"
 import { OpenAIPlugin } from "./provider/openai.js"
 import { SnowflakeCortexPlugin } from "./provider/snowflake-cortex.js"
@@ -50,7 +49,6 @@ export const ProviderPlugins: PluginInternal.InternalPlugin[] = [
   KiloPlugin,
   LLMGatewayPlugin,
   MistralPlugin,
-  ModalPlugin,
   NvidiaPlugin,
   OpencodePlugin,
   SnowflakeCortexPlugin,

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

@@ -1,176 +0,0 @@
-import { Money } from "@opencode-ai/schema/money"
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Schema, Semaphore, Stream } from "effect"
-import { Bus } from "../../bus.js"
-import { Catalog } from "../../catalog.js"
-import { Integration } from "../../integration.js"
-import { Model } from "../../model.js"
-import { Provider } from "../../provider.js"
-
-const providerID = Provider.ID.make("modal")
-
-const ReasoningOption = Schema.Struct({
-  type: Schema.Literal("effort"),
-  values: Schema.Array(Schema.NullOr(Schema.String)),
-})
-
-const Response = Schema.Struct({
-  data: Schema.Array(
-    Schema.Struct({
-      id: Schema.String,
-      base_model_id: Schema.optional(Schema.String),
-      hugging_face_id: Schema.optional(Schema.String),
-      name: Schema.optional(Schema.String),
-      input_modalities: Schema.optional(Schema.Array(Schema.String)),
-      output_modalities: Schema.optional(Schema.Array(Schema.String)),
-      context_length: Schema.optional(Schema.Number),
-      max_output_length: Schema.optional(Schema.Number),
-      pricing: Schema.optional(
-        Schema.Struct({
-          prompt: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
-          completion: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
-          input_cache_read: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
-        }),
-      ),
-      supported_features: Schema.optional(Schema.Array(Schema.String)),
-      reasoning_options: Schema.optional(Schema.Array(ReasoningOption)),
-      interleaved: Schema.optional(
-        Schema.Union([
-          Schema.Boolean,
-          Schema.Struct({ field: Schema.Literals(["reasoning", "reasoning_content", "reasoning_details"]) }),
-        ]),
-      ),
-    }),
-  ),
-})
-
-const decode = Schema.decodeUnknownSync(Response)
-
-export const ModalPlugin = define({
-  id: "opencode.provider.modal",
-  effect: Effect.fn(function* (ctx) {
-    const bus = yield* Bus.Service
-    const catalog = yield* Catalog.Service
-    const loading = Semaphore.makeUnsafe(1)
-    let templates: Map<Model.ID, Model.Info> | undefined
-    let models: Map<Model.ID, Model.Info> | undefined
-
-    const load = Effect.fn("ModalPlugin.load")(function* () {
-      const existing =
-        templates ??
-        new Map(
-          (yield* catalog.model.all())
-            .filter((model) => model.providerID === providerID)
-            .map((model) => [model.id, model]),
-        )
-      templates = existing
-      const connection = yield* ctx.integration.connection.active("modal")
-      const credential = connection
-        ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.catch(() => Effect.succeed(undefined)))
-        : undefined
-      const provider = yield* catalog.provider.get(providerID)
-      const baseURL = typeof provider?.settings?.baseURL === "string" ? provider.settings.baseURL : undefined
-      if (credential?.type !== "key" || !baseURL) {
-        models = new Map()
-        return
-      }
-
-      models = yield* Effect.tryPromise({
-        try: () => discover(baseURL, credential.key, existing),
-        catch: (cause) => cause,
-      }).pipe(
-        Effect.catch((cause) =>
-          Effect.logWarning("failed to sync Modal models", { cause }).pipe(Effect.as(new Map<Model.ID, Model.Info>())),
-        ),
-      )
-    })
-
-    yield* ctx.catalog.transform((draft) => {
-      if (!models) return
-      const provider = draft.provider.get(providerID)
-      if (!provider) return
-      for (const id of provider.models.keys()) {
-        if (!models.has(Model.ID.make(id))) draft.model.remove(providerID, Model.ID.make(id))
-      }
-      for (const [id, model] of models) {
-        draft.model.update(providerID, id, (item) => Object.assign(item, structuredClone(model)))
-      }
-    })
-    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
-    yield* bus.subscribe(Integration.Event.ConnectionUpdated).pipe(
-      Stream.filter((event) => event.data.integrationID === Integration.ID.make("modal")),
-      Stream.runForEach(refresh),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    yield* refresh().pipe(Effect.forkScoped)
-  }),
-})
-
-async function discover(baseURL: string, apiKey: string, templates: ReadonlyMap<Model.ID, Model.Info>) {
-  const response = await fetch(`${baseURL.replace(/\/+$/, "")}/models`, {
-    headers: { Authorization: `Bearer ${apiKey}` },
-    signal: AbortSignal.timeout(3_000),
-  })
-  if (!response.ok) throw new Error(`Failed to fetch Modal models: ${response.status}`)
-
-  return new Map(
-    decode(await response.json()).data.map((item) => {
-      const id = Model.ID.make(item.id)
-      const template = templates.get(Model.ID.make(item.base_model_id ?? item.hugging_face_id ?? item.id))
-      return [id, build(id, item, baseURL, template)]
-    }),
-  )
-}
-
-function build(id: Model.ID, item: (typeof Response.Type)["data"][number], baseURL: string, template?: Model.Info) {
-  const fallback: Model.Info = template ?? Model.Info.make(Model.Info.default(providerID, id))
-  const baseCost = fallback.cost[0]
-  const variants = item.reasoning_options?.flatMap((option) =>
-    option.values.map((value) => {
-      const effort = value ?? "none"
-      return {
-        id: Model.VariantID.make(effort),
-        settings: { reasoningEffort: effort },
-      }
-    }),
-  )
-  return Model.Info.make({
-    ...structuredClone(fallback),
-    id,
-    modelID: id,
-    providerID,
-    name: item.name ?? fallback.name,
-    compatibility: Model.compatibility(item.interleaved) ?? fallback.compatibility,
-    package: fallback.package ?? Provider.aisdk("@ai-sdk/openai-compatible"),
-    settings: Provider.mergeOverlay(fallback.settings, { baseURL }),
-    capabilities: {
-      tools: item.supported_features?.includes("tools") ?? fallback.capabilities.tools,
-      input: item.input_modalities ? [...item.input_modalities] : [...fallback.capabilities.input],
-      output: item.output_modalities ? [...item.output_modalities] : [...fallback.capabilities.output],
-    },
-    variants: variants ?? [...fallback.variants],
-    cost: [
-      {
-        input: price(item.pricing?.prompt, baseCost?.input ?? Money.USDPerMillionTokens.zero),
-        output: price(item.pricing?.completion, baseCost?.output ?? Money.USDPerMillionTokens.zero),
-        cache: {
-          read: price(item.pricing?.input_cache_read, baseCost?.cache.read ?? Money.USDPerMillionTokens.zero),
-          write: baseCost?.cache.write ?? Money.USDPerMillionTokens.zero,
-        },
-      },
-    ],
-    limit: {
-      context: item.context_length ?? fallback.limit.context,
-      input: fallback.limit.input,
-      output: item.max_output_length ?? fallback.limit.output,
-    },
-    status: fallback.status,
-    enabled: fallback.enabled,
-  })
-}
-
-function price(value: string | number | undefined, fallback: number) {
-  if (value === undefined) return Money.USDPerMillionTokens.make(fallback)
-  const parsed = Number(value)
-  return Money.USDPerMillionTokens.make(Number.isFinite(parsed) ? parsed * 1_000_000 : fallback)
-}

packages/core/src/session.ts

@@ -51,6 +51,7 @@ 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
 //
@@ -165,6 +166,10 @@ 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
@@ -304,6 +309,7 @@ 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>()
@@ -447,6 +453,11 @@ 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)
@@ -454,6 +465,7 @@ 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)
       }),
@@ -652,7 +664,12 @@ 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 })
+                .create({
+                  command: input.command,
+                  cwd: session.location.directory,
+                  timeout: 0,
+                  metadata: { sessionID: input.sessionID },
+                })
                 .pipe(Effect.orDie)
             }).pipe(Effect.provide(locations.get(session.location)))
             yield* bus.publish(
@@ -1102,6 +1119,7 @@ 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

@@ -0,0 +1,33 @@
+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,6 +15,8 @@ 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,
@@ -76,6 +78,7 @@ 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>()
@@ -184,13 +187,18 @@ 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: {
-            ...process.env,
+            ...(sessionEnvironment ?? process.env),
             TERM: "xterm-256color",
             OPENCODE_TERMINAL: "1",
           },
@@ -349,7 +357,15 @@ export function configured(options?: ShellSelect.Options) {
   return makeLocationNode({
     service: Service,
     layer: layer(options),
-    deps: [Bus.node, Location.node, Config.node, Global.node, Environment.node, PluginHooks.node],
+    deps: [
+      Bus.node,
+      Location.node,
+      Config.node,
+      Global.node,
+      Environment.node,
+      PluginHooks.node,
+      SessionEnvironment.node,
+    ],
   })
 }
 

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

@@ -1,143 +0,0 @@
-import { Catalog } from "@opencode-ai/core/catalog"
-import { Integration } from "@opencode-ai/core/integration"
-import { Model } from "@opencode-ai/core/model"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { ModalPlugin } from "@opencode-ai/core/plugin/provider/modal"
-import { Provider } from "@opencode-ai/core/provider"
-import { State } from "@opencode-ai/core/state"
-import { Money } from "@opencode-ai/schema/money"
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { testEffect } from "../lib/effect"
-import { PluginTestLayer } from "./fixture"
-
-const it = testEffect(PluginTestLayer)
-const providerID = Provider.ID.make("modal")
-const integrationID = Integration.ID.make("modal")
-const baseModelID = Model.ID.make("thinkingmachines/Inkling-NVFP4")
-const runtimeModelID = Model.ID.make("workspace--inkling.us-west.modal.direct")
-
-function eventually<A>(
-  effect: Effect.Effect<A>,
-  predicate: (value: A) => boolean,
-  remaining = 1000,
-): Effect.Effect<A, Error> {
-  return Effect.gen(function* () {
-    const value = yield* effect
-    if (predicate(value)) return value
-    if (remaining === 0) return yield* Effect.fail(new Error("Timed out waiting for value"))
-    yield* Effect.promise(() => Bun.sleep(1))
-    return yield* eventually(effect, predicate, remaining - 1)
-  })
-}
-
-const setup = Effect.fn(function* (baseURL: string, key?: string) {
-  const catalog = yield* Catalog.Service
-  const integrations = yield* Integration.Service
-  yield* integrations.transform((draft) => {
-    draft.method.update({ integrationID, method: { type: "key" } })
-  })
-  if (key) yield* integrations.connection.key({ integrationID, key })
-  yield* State.batch(
-    Effect.gen(function* () {
-      yield* catalog.transform((draft) => {
-        draft.provider.update(providerID, (provider) => {
-          provider.name = "Modal"
-          provider.package = Provider.aisdk("@ai-sdk/openai-compatible")
-          provider.settings = { baseURL }
-          provider.integrationID = integrationID
-        })
-        draft.model.update(providerID, baseModelID, (model) => {
-          model.name = "Inkling"
-          model.family = Model.Family.make("ling")
-          model.compatibility = { reasoningField: "reasoning_content" }
-          model.capabilities = { tools: true, input: ["text", "image", "audio"], output: ["text"] }
-          model.variants = [{ id: Model.VariantID.make("fallback"), settings: { reasoningEffort: "fallback" } }]
-          model.cost = [
-            {
-              input: Money.USDPerMillionTokens.make(1),
-              output: Money.USDPerMillionTokens.make(4),
-              cache: {
-                read: Money.USDPerMillionTokens.make(0.2),
-                write: Money.USDPerMillionTokens.zero,
-              },
-            },
-          ]
-          model.limit = { context: 128_000, output: 8_192 }
-          model.time = { released: Date.parse("2026-07-15") }
-        })
-      })
-      yield* ModalPlugin.effect(yield* PluginHost.make(yield* Plugin.Service))
-    }),
-  )
-})
-
-it.live("discovers Modal workspace models", () =>
-  Effect.gen(function* () {
-    const requests: Array<{ authorization: string | null; path: string }> = []
-    using server = Bun.serve({
-      port: 0,
-      fetch(request) {
-        requests.push({ authorization: request.headers.get("authorization"), path: new URL(request.url).pathname })
-        return Response.json({
-          data: [
-            {
-              id: runtimeModelID,
-              base_model_id: baseModelID,
-              name: "Thinking Machines: Inkling",
-              input_modalities: ["text", "image", "audio"],
-              output_modalities: ["text"],
-              context_length: 1_048_576,
-              max_output_length: 262_144,
-              pricing: { prompt: "0.0000012", completion: "0.000005", input_cache_read: "0.00000027" },
-              supported_features: ["tools", "reasoning"],
-              reasoning_options: [{ type: "effort", values: ["none", "low", "high"] }],
-              interleaved: { field: "reasoning_content" },
-            },
-          ],
-        })
-      },
-    })
-    yield* setup(`${server.url}v1`, "test-token")
-
-    const models = yield* eventually(
-      (yield* Catalog.Service).model
-        .all()
-        .pipe(Effect.map((models) => models.filter((model) => model.providerID === providerID))),
-      (models) => models.some((model) => model.id === runtimeModelID),
-    )
-    expect(requests).toEqual([{ authorization: "Bearer test-token", path: "/v1/models" }])
-    expect(models).toHaveLength(1)
-    expect(models[0]).toMatchObject({
-      id: runtimeModelID,
-      modelID: runtimeModelID,
-      name: "Thinking Machines: Inkling",
-      family: "ling",
-      compatibility: { reasoningField: "reasoning_content" },
-      settings: { baseURL: `${server.url}v1` },
-      capabilities: { tools: true, input: ["text", "image", "audio"], output: ["text"] },
-      variants: [
-        { id: "none", settings: { reasoningEffort: "none" } },
-        { id: "low", settings: { reasoningEffort: "low" } },
-        { id: "high", settings: { reasoningEffort: "high" } },
-      ],
-      cost: [{ input: 1.2, output: 5, cache: { read: 0.27, write: 0 } }],
-      limit: { context: 1_048_576, output: 262_144 },
-    })
-  }),
-)
-
-it.live("hides static Modal models when discovery fails", () =>
-  Effect.gen(function* () {
-    using server = Bun.serve({ port: 0, fetch: () => new Response(null, { status: 503 }) })
-    yield* setup(`${server.url}v1`, "test-token")
-    const models = yield* eventually(
-      (yield* Catalog.Service).model
-        .all()
-        .pipe(Effect.map((models) => models.filter((model) => model.providerID === providerID))),
-      (models) => models.length === 0,
-    )
-    expect(models).toEqual([])
-  }),
-)

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

@@ -679,13 +679,18 @@ 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" } })
 
-        yield* session.shell({ sessionID: created.id, command: "echo hello" })
+        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 })
 
         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: "echo hello", status: "exited", exit: 0 })
-        expect(shell?.output?.output).toContain("hello")
+        expect(shell).toMatchObject({ type: "shell", command, status: "exited", exit: 0 })
+        expect(shell?.output?.output).toContain("attached")
         expect(shell?.output?.truncated).toBe(false)
         expect(shell?.time.completed).toBeDefined()
       }),

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

@@ -0,0 +1,30 @@
+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,6 +12,7 @@ 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"
@@ -32,6 +33,7 @@ const it = testEffect(
       Bus.node,
       SessionProjector.node,
       SessionStore.node,
+      SessionEnvironment.node,
       Session.node,
       LocationServiceMap.node,
     ]),
@@ -50,6 +52,8 @@ 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
 
@@ -57,6 +61,9 @@ 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-shell.test.ts

@@ -260,6 +260,36 @@ 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()),

packages/protocol/src/groups/session.ts

@@ -693,6 +693,20 @@ 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,6 +196,22 @@ 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/tui/src/app.tsx

@@ -41,6 +41,7 @@ import {
   useTuiApp,
   useTuiPaths,
   useTuiStartup,
+  useTuiTerminalEnvironment,
   type TuiApp,
 } from "./context/runtime"
 import { DialogProvider, useDialog } from "./ui/dialog"
@@ -185,6 +186,7 @@ export type TuiInput = {
   args: Args
   config: Config.Interface
   packages: PackageResolver
+  environment?: Readonly<Record<string, string>>
   terminalHandoff?: () => Promise<
     | {
         readonly renderer: CliRenderer
@@ -332,6 +334,7 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
                                   : process.env.DISPLAY
                                     ? "x11"
                                     : undefined,
+                                variables: input.environment,
                               }}
                             >
                               <TuiStartupProvider
@@ -480,6 +483,17 @@ 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

@@ -1206,6 +1206,19 @@ 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/context/runtime.tsx

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

script/publish.ts

@@ -68,22 +68,6 @@ await $`bun ./packages/core/script/publish.ts`
 console.log("\n=== ui ===\n")
 await $`bun ./packages/ui/script/publish.ts`
 
-if (Script.channel === "beta") {
-  const packages = [
-    "@opencode-ai/schema",
-    "@opencode-ai/codemode",
-    "@opencode-ai/theme",
-    "@opencode-ai/ai",
-    "@opencode-ai/util",
-    "@opencode-ai/protocol",
-    "@opencode-ai/client",
-    "@opencode-ai/plugin",
-    "@opencode-ai/core",
-    "@opencode-ai/ui",
-  ]
-  await Promise.all(packages.map((name) => $`npm dist-tag add ${`${name}@${Script.version}`} next`))
-}
-
 if (Script.release) {
   await $`bun ./packages/desktop/scripts/finalize-latest-json.ts`
   await $`bun ./packages/desktop/scripts/finalize-latest-yml.ts`