test(core): tighten environment conformance cleanup

packages/cli/src/run/run.ts

@@ -94,9 +94,11 @@ async function execute(input: RunCommandInput, prepared: Prepared, endpoint: End
     prepare: async (next) => {
       const selected =
         next.model ??
-        (await client.model
-          .default({ location: { directory: next.location.directory, workspace: next.location.workspaceID } })
-          .then((result) => result.data))
+        (options.variant
+          ? await client.model
+              .default({ location: { directory: next.location.directory, workspace: next.location.workspaceID } })
+              .then((result) => result.data)
+          : undefined)
       const model = selected
         ? {
             providerID: selected.providerID,
@@ -106,12 +108,7 @@ async function execute(input: RunCommandInput, prepared: Prepared, endpoint: End
         : undefined
       if ((options.variant ?? explicit?.variant) && !model)
         throw new RunTargetError("Cannot select a variant before selecting a model", next.session?.id)
-      const agent =
-        next.agent ??
-        (await client.agent
-          .list({ location: { directory: next.location.directory, workspace: next.location.workspaceID } })
-          .then((result) => result.data.find((item) => item.mode !== "subagent" && !item.hidden)?.id))
-      return { model, agent }
+      return { model, agent: next.agent }
     },
   }).catch((error) => {
     if (!(error instanceof RunTargetError)) throw error

packages/cli/src/session-target.ts

@@ -56,16 +56,13 @@ export async function resolveSessionTarget(input: {
     agent: input.agent ?? selected?.agent,
     signal: input.signal,
   })
-  if (!selected && (!prepared.agent || !prepared.model)) {
-    throw new SessionTargetMutationError(new Error("Creating a session requires an agent and model"))
-  }
   const session =
     selected ??
     (await input.client.session
       .create(
         {
-          agent: prepared.agent!,
-          model: prepared.model!,
+          agent: prepared.agent,
+          model: prepared.model,
           location: { directory: location.directory, workspaceID: location.workspaceID },
         },
         ...requestOptions(input.signal),

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

@@ -61,11 +61,7 @@ describe("session target resolver", () => {
     spyOn(client.location, "get").mockResolvedValue(location("/server", "work_1"))
     const create = spyOn(client.session, "create").mockImplementation(async (input) => {
       order.push("create")
-      expect(input).toMatchObject({
-        agent: "prepared",
-        model: { providerID: "openai", id: "gpt-5" },
-        location: { directory: "/server", workspaceID: "work_1" },
-      })
+      expect(input).toMatchObject({ agent: "prepared", location: { directory: "/server", workspaceID: "work_1" } })
       return session("ses_fresh", "/server", "work_1")
     })
 
@@ -75,22 +71,20 @@ describe("session target resolver", () => {
       prepare: async (input) => {
         order.push("prepare")
         expect(input.location.workspaceID).toBe("work_1")
-        return { model: { providerID: "openai", id: "gpt-5" }, agent: "prepared" }
+        return { model: input.model, agent: "prepared" }
       },
     })
     expect(create).toHaveBeenCalledTimes(1)
     expect(order).toEqual(["prepare", "create"])
   })
 
-  test("requires an explicit agent and model for a fresh Session", async () => {
+  test("uses the agent resolved by the server for a fresh Session", async () => {
     const client = OpenCode.make({ baseUrl: "https://opencode.test" })
     spyOn(client.location, "get").mockResolvedValue(location("/project"))
-    const create = spyOn(client.session, "create")
+    spyOn(client.session, "create").mockResolvedValue({ ...session("ses_fresh", "/project"), agent: "review" })
 
-    await expect(resolveSessionTarget({ client, prepare })).rejects.toThrow(
-      "Creating a session requires an agent and model",
-    )
-    expect(create).not.toHaveBeenCalled()
+    const target = await resolveSessionTarget({ client, prepare })
+    expect(target.agent).toBe("review")
   })
 
   test("does not retry an ambiguous Session creation", async () => {

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

@@ -120,12 +120,12 @@ export type SessionListOperation<E = never> = (input?: Endpoint5_0Input) => Effe
 export type Endpoint5_1Input = {
   readonly id?: Session.ID | undefined
   readonly title?: string | undefined
-  readonly agent: Agent.ID
-  readonly model: Model.Ref
+  readonly agent?: Agent.ID | undefined
+  readonly model?: Model.Ref | undefined
   readonly location?: Location.Ref | undefined
 }
 export type Endpoint5_1Output = Session.Info
-export type SessionCreateOperation<E = never> = (input: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>
+export type SessionCreateOperation<E = never> = (input?: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>
 
 export type Endpoint5_2Input = {
   readonly info: Session.Info

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

@@ -305,15 +305,15 @@ const Endpoint5_0 = (raw: RawClient["server.session"]) => (input?: Endpoint5_0In
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_1 = (raw: RawClient["server.session"]) => (input: Endpoint5_1Input) =>
+const Endpoint5_1 = (raw: RawClient["server.session"]) => (input?: Endpoint5_1Input) =>
   preserveEffect<Endpoint5_1Output>()(
     raw["session.create"]({
       payload: {
-        id: input["id"],
-        title: input["title"],
-        agent: input["agent"],
-        model: input["model"],
-        location: input["location"],
+        id: input?.["id"],
+        title: input?.["title"],
+        agent: input?.["agent"],
+        model: input?.["model"],
+        location: input?.["location"],
       },
     }).pipe(
       Effect.mapError(mapClientError),

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

@@ -464,17 +464,17 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      create: (input: SessionCreateInput, requestOptions?: RequestOptions) =>
+      create: (input?: SessionCreateInput, requestOptions?: RequestOptions) =>
         request<{ readonly data: SessionCreateOutput }>(
           {
             method: "POST",
             path: `/api/session`,
             body: {
-              id: input["id"],
-              title: input["title"],
-              agent: input["agent"],
-              model: input["model"],
-              location: input["location"],
+              id: input?.["id"],
+              title: input?.["title"],
+              agent: input?.["agent"],
+              model: input?.["model"],
+              location: input?.["location"],
             },
             successStatus: 200,
             declaredStatuses: [401, 400],

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

@@ -2436,36 +2436,36 @@ export type SessionCreateInput = {
   readonly id?: {
     readonly id?: string | null
     readonly title?: string | null
-    readonly agent: string
-    readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["id"]
   readonly title?: {
     readonly id?: string | null
     readonly title?: string | null
-    readonly agent: string
-    readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["title"]
-  readonly agent: {
+  readonly agent?: {
     readonly id?: string | null
     readonly title?: string | null
-    readonly agent: string
-    readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["agent"]
-  readonly model: {
+  readonly model?: {
     readonly id?: string | null
     readonly title?: string | null
-    readonly agent: string
-    readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["model"]
   readonly location?: {
     readonly id?: string | null
     readonly title?: string | null
-    readonly agent: string
-    readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
+    readonly agent?: string | null
+    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["location"]
 }

packages/client/test/effect.test.ts

@@ -181,8 +181,6 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     const page = yield* client.session.list({ limit: 10 })
     const active = yield* client.session.active()
     const created = yield* client.session.create({
-      agent: Agent.ID.make("build"),
-      model: Model.Ref.make({ id: "claude", providerID: "anthropic" }),
       location: Location.Ref.make({ directory: AbsolutePath.make("/tmp/project") }),
     })
     yield* client.session.switchAgent({ sessionID: Session.ID.make("ses_test"), agent: Agent.ID.make("build") })

packages/client/test/promise.test.ts

@@ -454,11 +454,7 @@ test("session methods use the public HTTP contract", async () => {
 
   const page = await client.session.list({ limit: 10, order: "desc", parentID: null })
   const active = await client.session.active()
-  const created = await client.session.create({
-    agent: "build",
-    model: { id: "claude", providerID: "anthropic" },
-    location: { directory: "/tmp/project" },
-  })
+  const created = await client.session.create({ location: { directory: "/tmp/project" } })
   await client.session.switchAgent({ sessionID: "ses_test", agent: "build" })
   await client.session.switchModel({
     sessionID: "ses_test",
@@ -532,7 +528,7 @@ test("middleware errors remain declared client errors", async () => {
   })
 
   try {
-    await client.session.create({ agent: "build", model: { id: "claude", providerID: "anthropic" } })
+    await client.session.create({})
     throw new Error("Expected request to fail")
   } catch (error) {
     expect(isUnauthorizedError(error)).toBe(true)

packages/core/package.json

@@ -17,6 +17,7 @@
     "opencode": "./bin/opencode"
   },
   "exports": {
+    "./environment": "./src/environment/index.ts",
     "./session/runner": "./src/session/runner/index.ts",
     "./instructions": "./src/instructions/index.ts",
     "./*": "./src/*.ts"

packages/core/src/environment/driver.ts

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

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

@@ -0,0 +1,185 @@
+import { Effect, Stream } from "effect"
+import { ChildProcess } from "effect/unstable/process"
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
+import { collectStream } from "@opencode-ai/util/process"
+import { Failed, NotFound, WrongKind, type FileInfo, type FileType, type FilesImpl } from "./files"
+
+const MAX_DATA_BYTES = 64 * 1024 * 1024
+const MAX_ERROR_BYTES = 64 * 1024
+const NOT_FOUND = 44
+const WRONG_KIND = 45
+const FAILED = 46
+
+const loadMetadata = (flags = "") => `
+metadata=$(stat ${flags} -c '%F\t%s\t%Y' -- "$1" 2>&1) || {
+  case "$metadata" in
+    *'No such file or directory'*|*'Not a directory'*) exit ${NOT_FOUND} ;;
+    *) printf '%s' "$metadata" >&2; exit ${FAILED} ;;
+  esac
+}
+`
+
+const statScript = `
+${loadMetadata()}
+printf '%s\n' "$metadata"
+`
+
+const readScript = `
+${loadMetadata("-L")}
+kind=\${metadata%%	*}
+if [ "$kind" != 'regular file' ] && [ "$kind" != 'regular empty file' ]; then
+  printf '%s' "$kind" >&2
+  exit ${WRONG_KIND}
+fi
+printf '%s\n' "$metadata"
+if [ "$2" = range ]; then
+  dd if="$1" iflag=skip_bytes,count_bytes skip="$3" count="$4" status=none
+else
+  cat -- "$1"
+fi
+`
+
+const listScript = `
+${loadMetadata()}
+kind=\${metadata%%	*}
+if [ "$kind" != directory ]; then
+  printf '%s' "$kind" >&2
+  exit ${WRONG_KIND}
+fi
+find "$1" -mindepth 1 -maxdepth 1 -printf '%y\0%f\0'
+`
+
+interface Result {
+  readonly exitCode: number
+  readonly stdout: Uint8Array
+  readonly stderr: Uint8Array
+}
+
+export const execDefaults = (spawner: ChildProcessSpawner["Service"]): FilesImpl => {
+  const run = (
+    path: string,
+    script: string,
+    args: ReadonlyArray<string> = [],
+    stdin?: Uint8Array,
+  ): Effect.Effect<Result, Failed> =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const command = ChildProcess.make("sh", ["-c", script, "sh", path, ...args], {
+          env: { LC_ALL: "C" },
+          extendEnv: true,
+          stdin: stdin === undefined ? undefined : Stream.make(stdin),
+        })
+        const handle = yield* spawner.spawn(command).pipe(Effect.mapError((cause) => new Failed({ path, cause })))
+        const [stdout, stderr, exitCode] = yield* Effect.all(
+          [
+            collectStream(handle.stdout, MAX_DATA_BYTES),
+            collectStream(handle.stderr, MAX_ERROR_BYTES),
+            handle.exitCode,
+          ],
+          { concurrency: "unbounded" },
+        ).pipe(Effect.mapError((cause) => new Failed({ path, cause })))
+        if (stdout.truncated || stderr.truncated) {
+          return yield* new Failed({ path, cause: new Error("Process output exceeded its collection limit") })
+        }
+        return { exitCode, stdout: stdout.buffer, stderr: stderr.buffer }
+      }),
+    )
+
+  const classify = <A>(
+    path: string,
+    result: Result,
+    success: (stdout: Uint8Array) => A,
+  ): Effect.Effect<A, NotFound | WrongKind | Failed> => {
+    if (result.exitCode === 0) return Effect.sync(() => success(result.stdout))
+    if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
+    if (result.exitCode === WRONG_KIND) {
+      return Effect.fail(new WrongKind({ path, actual: parseType(new TextDecoder().decode(result.stderr)) }))
+    }
+    return Effect.fail(processFailure(path, result))
+  }
+
+  const stat: FilesImpl["stat"] = (path) =>
+    run(path, statScript).pipe(Effect.flatMap((result) => classifyStat(path, result)))
+
+  const complete = (path: string, result: Result) =>
+    result.exitCode === 0 ? Effect.void : Effect.fail(processFailure(path, result))
+
+  return {
+    stat,
+    read: (path, range) =>
+      run(
+        path,
+        readScript,
+        range === undefined ? ["whole"] : ["range", String(range.offset), String(range.length)],
+      ).pipe(
+        Effect.flatMap((result) =>
+          classify(path, result, (stdout) => {
+            const newline = stdout.indexOf(10)
+            if (newline < 0) throw new Error("Missing read metadata header")
+            return {
+              info: parseInfo(stdout.slice(0, newline)),
+              bytes: stdout.slice(newline + 1),
+            }
+          }),
+        ),
+      ),
+    write: (path, bytes) =>
+      run(path, `mkdir -p "$(dirname "$1")" && cat > "$1"`, [], bytes).pipe(
+        Effect.flatMap((result) => complete(path, result)),
+      ),
+    list: (path) => run(path, listScript).pipe(Effect.flatMap((result) => classify(path, result, parseList))),
+    remove: (path) => run(path, `rm -rf -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
+    move: (from, to) =>
+      run(
+        from,
+        `${loadMetadata()}
+mv -- "$1" "$2"`,
+        [to],
+      ).pipe(Effect.flatMap((result) => classifyMove(from, result))),
+    mkdir: (path) => run(path, `mkdir -p -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
+  }
+}
+
+const classifyStat = (path: string, result: Result): Effect.Effect<FileInfo, NotFound | Failed> => {
+  if (result.exitCode === 0) return Effect.sync(() => parseInfo(result.stdout))
+  if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
+  return Effect.fail(processFailure(path, result))
+}
+
+const classifyMove = (path: string, result: Result): Effect.Effect<void, NotFound | Failed> => {
+  if (result.exitCode === 0) return Effect.void
+  if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
+  return Effect.fail(processFailure(path, result))
+}
+
+const processFailure = (path: string, result: Result) =>
+  new Failed({
+    path,
+    cause: new Error(new TextDecoder().decode(result.stderr).trim() || `Process exited with code ${result.exitCode}`),
+  })
+
+const parseInfo = (bytes: Uint8Array): FileInfo => {
+  const [rawType, rawSize, rawMtime] = new TextDecoder().decode(bytes).trim().split("\t")
+  const size = Number(rawSize)
+  const mtimeMs = Number(rawMtime) * 1_000
+  if (!rawType || !Number.isFinite(size) || !Number.isFinite(mtimeMs)) throw new Error("Invalid stat output")
+  return { type: parseType(rawType), size, mtimeMs }
+}
+
+const parseType = (value: string): FileType => {
+  if (value === "regular file" || value === "regular empty file" || value === "f") return "file"
+  if (value === "directory" || value === "d") return "directory"
+  if (value === "symbolic link" || value === "l") return "symlink"
+  return "other"
+}
+
+const parseList = (bytes: Uint8Array) => {
+  const fields = new TextDecoder().decode(bytes).split("\0")
+  fields.pop()
+  if (fields.length % 2 !== 0) throw new Error("Invalid find output")
+  return fields
+    .filter((_, index) => index % 2 === 0)
+    .map((type, index) => ({ name: fields[index * 2 + 1], type: parseType(type) }))
+}
+
+export * as EnvironmentExecDefaults from "./exec-defaults"

packages/core/src/environment/files.ts

@@ -0,0 +1,53 @@
+import { Effect, Schema } from "effect"
+
+export const FileType = Schema.Literals(["file", "directory", "symlink", "other"])
+export type FileType = typeof FileType.Type
+
+export interface FileInfo {
+  readonly type: FileType
+  readonly size: number
+  readonly mtimeMs: number
+}
+
+export interface DirEntry {
+  readonly name: string
+  readonly type: FileType
+}
+
+export class NotFound extends Schema.TaggedErrorClass<NotFound>()("Environment.NotFound", {
+  path: Schema.String,
+}) {}
+
+export class WrongKind extends Schema.TaggedErrorClass<WrongKind>()("Environment.WrongKind", {
+  path: Schema.String,
+  actual: FileType,
+}) {}
+
+export class Failed extends Schema.TaggedErrorClass<Failed>()("Environment.Failed", {
+  path: Schema.String,
+  cause: Schema.Defect(),
+}) {}
+
+export interface FilesImpl {
+  /**
+   * Reads a file, following a final symlink so `info` describes the target whose bytes are returned.
+   * The process-backed default caps collected output at 64 MiB; larger whole-file reads fail with
+   * `Failed`, so callers must use ranges for larger files.
+   */
+  readonly read: (
+    path: string,
+    range?: { readonly offset: number; readonly length: number },
+  ) => Effect.Effect<{ readonly info: FileInfo; readonly bytes: Uint8Array }, NotFound | WrongKind | Failed>
+  readonly write: (path: string, bytes: Uint8Array) => Effect.Effect<void, Failed>
+  /** Describes the path entry itself, so a final symlink is reported as `symlink` rather than followed. */
+  readonly stat: (path: string) => Effect.Effect<FileInfo, NotFound | Failed>
+  /** Lists a directory entry without following a final symlink; intermediate symlinks are traversed. */
+  readonly list: (path: string) => Effect.Effect<ReadonlyArray<DirEntry>, NotFound | WrongKind | Failed>
+  readonly remove: (path: string) => Effect.Effect<void, Failed>
+  readonly move: (from: string, to: string) => Effect.Effect<void, NotFound | Failed>
+  readonly mkdir: (path: string) => Effect.Effect<void, Failed>
+}
+
+export interface Files extends FilesImpl {}
+
+export * as EnvironmentFiles from "./files"

packages/core/src/environment/index.ts

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

packages/core/src/environment/memory.ts

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

packages/core/src/plugin/host.ts

@@ -340,12 +340,12 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
       hook: (name, callback) => hooks.register("session", name, callback),
       create: (input) =>
         runtime.session.create({
-          id: input.id,
-          title: input.title,
-          agent: input.agent,
-          model: input.model,
+          id: input?.id,
+          title: input?.title,
+          agent: input?.agent,
+          model: input?.model,
           location:
-            input.location ?? Location.Ref.make({ directory: location.directory, workspaceID: location.workspaceID }),
+            input?.location ?? Location.Ref.make({ directory: location.directory, workspaceID: location.workspaceID }),
         }),
       get: (input) => runtime.session.get(input.sessionID),
       prompt: runtime.session.prompt,

packages/core/src/plugin/promise.ts

@@ -269,21 +269,25 @@ export function fromPromise(plugin: Plugin) {
               register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
             create: (input) =>
               run(
-                host.session.create({
-                  id: input.id == null ? undefined : Session.ID.make(input.id),
-                  agent: Agent.ID.make(input.agent),
-                  model: model(input.model),
-                  location:
-                    input.location == null
-                      ? undefined
-                      : Location.Ref.make({
-                          directory: AbsolutePath.make(input.location.directory),
-                          workspaceID:
-                            input.location.workspaceID === undefined
-                              ? undefined
-                              : Workspace.ID.make(input.location.workspaceID),
-                        }),
-                }),
+                host.session.create(
+                  input === undefined
+                    ? undefined
+                    : {
+                        id: input.id == null ? undefined : Session.ID.make(input.id),
+                        agent: input.agent == null ? undefined : Agent.ID.make(input.agent),
+                        model: input.model == null ? undefined : model(input.model),
+                        location:
+                          input.location == null
+                            ? undefined
+                            : Location.Ref.make({
+                                directory: AbsolutePath.make(input.location.directory),
+                                workspaceID:
+                                  input.location.workspaceID === undefined
+                                    ? undefined
+                                    : Workspace.ID.make(input.location.workspaceID),
+                              }),
+                      },
+                ),
               ),
             get: (input) => run(host.session.get({ sessionID: Session.ID.make(input.sessionID) })),
             prompt: (input) =>

packages/core/test/environment.test.ts

@@ -0,0 +1,40 @@
+import fs from "node:fs/promises"
+import { Effect } from "effect"
+import { ChildProcessSpawner } from "effect/unstable/process"
+import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { execDefaults, Failed, makeFiles, makeMemoryDriver } from "../src/environment/index"
+import { tmpdir } from "./fixture/tmpdir"
+import { environmentConformance } from "./lib/environment-conformance"
+
+environmentConformance("memory environment", () => {
+  const driver = makeMemoryDriver()
+  return {
+    files: makeFiles(driver),
+    root: `/workspace-${crypto.randomUUID()}`,
+    symlink: driver.symlink,
+  }
+})
+
+environmentConformance(
+  "GNU exec environment",
+  async () => {
+    const spawner = await Effect.runPromise(
+      Effect.gen(function* () {
+        return yield* ChildProcessSpawner.ChildProcessSpawner
+      }).pipe(Effect.provide(LayerNode.compile(CrossSpawnSpawner.node))),
+    )
+    const tmp = await tmpdir("opencode-environment-")
+    return {
+      files: execDefaults(spawner),
+      root: tmp.path,
+      symlink: (target: string, link: string) =>
+        Effect.tryPromise({
+          try: () => fs.symlink(target, link),
+          catch: (cause) => new Failed({ path: link, cause }),
+        }),
+      dispose: () => tmp[Symbol.asyncDispose](),
+    }
+  },
+  process.platform !== "linux",
+)

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

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

packages/protocol/src/groups/session.ts

@@ -151,8 +151,8 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         payload: Schema.Struct({
           id: Session.ID.pipe(Schema.optional),
           title: Schema.String.pipe(Schema.optional),
-          agent: Agent.ID,
-          model: Model.Ref,
+          agent: Agent.ID.pipe(Schema.optional),
+          model: Model.Ref.pipe(Schema.optional),
           location: Location.Ref.pipe(Schema.optional),
         }),
         success: Schema.Struct({ data: Session.Info }),
@@ -160,7 +160,7 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         OpenApi.annotations({
           identifier: "v2.session.create",
           summary: "Create session",
-          description: "Create a session with an explicit agent and model at the requested location.",
+          description: "Create a session at the requested location.",
         }),
       ),
     )