fix(core): preserve session transfer identities

packages/cli/src/commands/commands.ts

@@ -68,10 +68,7 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
     }),
     Spec.make("debug", {
       description: "Debugging and troubleshooting tools",
-      commands: [
-        Spec.make("agents", { description: "List all agents" }),
-        Spec.make("config", { description: "Show resolved configuration" }),
-      ],
+      commands: [Spec.make("agents", { description: "List all agents" })],
     }),
     Spec.make("console", {
       description: "Manage OpenCode Console access",
@@ -140,6 +137,32 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
       description: "List all available models",
       params: ServerParams,
     }),
+    Spec.make("export", {
+      description: "Export session data as JSON",
+      params: {
+        ...ServerParams,
+        session: Flag.string("session").pipe(
+          Flag.withAlias("s"),
+          Flag.withDescription("Session ID to export to stdout"),
+          Flag.optional,
+        ),
+        sanitize: Flag.boolean("sanitize").pipe(
+          Flag.withDescription("Redact sensitive transcript and file data"),
+          Flag.withDefault(false),
+        ),
+      },
+    }),
+    Spec.make("import", {
+      description: "Import session data from a JSON file or URL",
+      params: {
+        ...ServerParams,
+        file: Argument.string("file").pipe(Argument.withDescription("JSON file or URL to import")),
+        directory: Flag.string("directory").pipe(
+          Flag.withDescription("Directory in which to import the session"),
+          Flag.optional,
+        ),
+      },
+    }),
     Spec.make("mini", {
       description: "Start the minimal interactive interface",
       params: {

packages/cli/src/commands/handlers/debug/config.ts

@@ -1,19 +0,0 @@
-import { EOL } from "os"
-import { Effect } from "effect"
-import { OpenCode } from "@opencode-ai/client"
-import { Service } from "@opencode-ai/client/effect/service"
-import { Commands } from "../../commands"
-import { Runtime } from "../../../framework/runtime"
-import { ServiceConfig } from "../../../services/service-config"
-
-export default Runtime.handler(
-  Commands.commands.debug.commands.config,
-  Effect.fn("cli.debug.config")(function* () {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const endpoint = found ?? (yield* Service.ensure(options))
-    const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
-    const entries = yield* Effect.promise(() => client.config.get({ location: { directory: process.cwd() } }))
-    process.stdout.write(JSON.stringify(entries, null, 2) + EOL)
-  }),
-)

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

@@ -22,7 +22,6 @@ export default Runtime.handler(Commands, (input) =>
     const server = yield* ServerConnection.resolve({
       server: Option.getOrUndefined(input.server),
       standalone: input.standalone,
-      mismatch: "replace",
       onStart: (reason, previousVersion) => {
         if (reason === "version-mismatch" && preflight.begin(previousVersion)) return
         process.stderr.write(

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

@@ -0,0 +1,140 @@
+import { OpenCode, type SessionInfo } from "@opencode-ai/client"
+import { Service } from "@opencode-ai/client/effect/service"
+import { Effect, Option } from "effect"
+import { EOL, tmpdir } from "node:os"
+import path from "node:path"
+import { emitKeypressEvents, type Key } from "node:readline"
+import { Commands } from "../commands"
+import { Runtime } from "../../framework/runtime"
+import { ServerConnection } from "../../services/server-connection"
+
+export default Runtime.handler(
+  Commands.commands.export,
+  Effect.fn("cli.export")(function* (input) {
+    const server = yield* ServerConnection.resolve({
+      server: Option.getOrUndefined(input.server),
+      standalone: input.standalone,
+    })
+    const client = OpenCode.make({
+      baseUrl: server.endpoint.url,
+      headers: Service.headers(server.endpoint),
+    })
+    const requested = Option.getOrUndefined(input.session)
+    const selected = requested
+      ? undefined
+      : yield* Effect.promise(async () => {
+          const location = await client.location.get({ location: { directory: process.cwd() } })
+          const page = await client.session.list({
+            directory: location.directory,
+            workspace: location.workspaceID,
+            parentID: null,
+            order: "desc",
+            limit: 50,
+          })
+          if (page.data.length === 0) {
+            process.stderr.write(`No sessions found${EOL}`)
+            return undefined
+          }
+          return selectSession(page.data, input.sanitize)
+        })
+    const sessionID = requested ?? selected?.session.id
+    if (!sessionID) return
+    const data = yield* Effect.promise(() =>
+      client.session.export({ sessionID, sanitize: selected?.sanitize ?? input.sanitize }),
+    )
+    process.stdout.write(yield* Effect.promise(() => writeExport(data, sessionID, requested !== undefined)))
+  }),
+)
+
+type Selection = { session: SessionInfo; sanitize: boolean }
+
+function selectSession(sessions: SessionInfo[], initialSanitize: boolean) {
+  if (!process.stdin.isTTY) return Promise.reject(new Error("Session ID is required when stdin is not interactive"))
+  const input = process.stdin
+  const output = process.stderr
+  const wasRaw = input.isRaw
+  const wasPaused = input.isPaused()
+  const date = new Intl.DateTimeFormat(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  })
+  const columns = output.columns ?? 100
+  const titleWidth = Math.max(8, Math.min(48, columns - 34))
+  let selected = 0
+  let offset = 0
+  let sanitize = initialSanitize
+  let height = 0
+
+  const render = () => {
+    const visible = sessions.slice(offset, offset + 10)
+    const lines = ["  \x1b[36mExport session\x1b[0m", ""]
+    lines.push(
+      ...visible.map((session) => {
+        const index = sessions.indexOf(session)
+        const title = (session.title ?? "Untitled session").slice(0, titleWidth).padEnd(titleWidth)
+        const updated = date.format(session.time.updated).slice(0, 18).padEnd(18)
+        const row = `${index === selected ? ">" : " "} ${title}  ${updated}  ${session.id.slice(-8)}`
+        return index === selected ? `\x1b[1m${row}\x1b[0m` : row
+      }),
+      "",
+      `  [${sanitize ? "x" : " "}] sanitize sensitive data`,
+      "",
+      "  navigate \x1b[2mup/down\x1b[0m   sanitize \x1b[2mspace\x1b[0m   export \x1b[2menter\x1b[0m   cancel \x1b[2mesc\x1b[0m",
+    )
+    if (height > 0) output.write(`\x1b[${height}F\x1b[J`)
+    output.write(lines.join(EOL) + EOL)
+    height = lines.length
+  }
+  const clear = () => {
+    if (height > 0) output.write(`\x1b[${height}F\x1b[J`)
+    output.write("\x1b[?25h")
+    input.removeListener("keypress", onKeypress)
+    input.setRawMode(wasRaw ?? false)
+    if (wasPaused) input.pause()
+  }
+  const onKeypress = (value: string | undefined, key: Key) => {
+    if (key.name === "up") {
+      selected = (selected - 1 + sessions.length) % sessions.length
+      if (selected === sessions.length - 1) offset = Math.max(0, sessions.length - 10)
+      if (selected < offset) offset = selected
+    }
+    if (key.name === "down") {
+      selected = (selected + 1) % sessions.length
+      if (selected === 0) offset = 0
+      if (selected >= offset + 10) offset = selected - 9
+    }
+    if (key.name === "space" || value === " ") sanitize = !sanitize
+    if (key.name === "return") return finish(sessions[selected])
+    if (key.name === "escape" || (key.ctrl && key.name === "c")) return cancel()
+    render()
+  }
+  const finish = (session: SessionInfo) => {
+    clear()
+    resolveSelection?.({ session, sanitize })
+  }
+  const cancel = () => {
+    clear()
+    resolveSelection?.()
+  }
+  let resolveSelection: ((selection?: Selection) => void) | undefined
+
+  emitKeypressEvents(input)
+  input.setRawMode(true)
+  input.resume()
+  input.on("keypress", onKeypress)
+  output.write("\x1b[?25l")
+  render()
+  return new Promise<Selection | undefined>((resolve) => {
+    resolveSelection = resolve
+  })
+}
+
+export async function writeExport(data: unknown, sessionID: string, stdout: boolean) {
+  const json = JSON.stringify(data, null, 2) + EOL
+  if (stdout) return json
+  const file = path.join(tmpdir(), `opencode-session-${sessionID}-${crypto.randomUUID().slice(0, 8)}.json`)
+  await Bun.write(file, json)
+  return file + EOL
+}

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

@@ -0,0 +1,60 @@
+import { OpenCode } from "@opencode-ai/client"
+import { Service } from "@opencode-ai/client/effect/service"
+import { Session } from "@opencode-ai/schema/session"
+import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
+import { Effect, Option, Schema } from "effect"
+import { EOL } from "node:os"
+import path from "node:path"
+import { Commands } from "../commands"
+import { Runtime } from "../../framework/runtime"
+import { ServerConnection } from "../../services/server-connection"
+
+export default Runtime.handler(
+  Commands.commands.import,
+  Effect.fn("cli.import")(function* (input) {
+    const text = yield* Effect.tryPromise({
+      try: () =>
+        input.file.startsWith("http://") || input.file.startsWith("https://")
+          ? fetch(input.file).then((response) => {
+              if (!response.ok) throw new Error(`Failed to fetch session data: ${response.statusText}`)
+              return response.text()
+            })
+          : Bun.file(input.file).text(),
+      catch: (cause) => new Error(`Failed to read session data: ${cause instanceof Error ? cause.message : String(cause)}`),
+    })
+    const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(SessionTransfer.Data))(text)
+    const encoded = Schema.encodeSync(SessionTransfer.Data)(data)
+    const server = yield* ServerConnection.resolve({
+      server: Option.getOrUndefined(input.server),
+      standalone: input.standalone,
+    })
+    const client = OpenCode.make({
+      baseUrl: server.endpoint.url,
+      headers: Service.headers(server.endpoint),
+    })
+    const location = yield* Effect.promise(() =>
+      client.location.get({
+        location: { directory: path.resolve(Option.getOrElse(input.directory, () => process.cwd())) },
+      }),
+    )
+    const response = yield* Effect.promise(() =>
+      fetch(new URL("/api/session/import", server.endpoint.url), {
+        method: "POST",
+        headers: { ...Service.headers(server.endpoint), "content-type": "application/json" },
+        body: JSON.stringify({
+          ...encoded,
+          location: { directory: location.directory, workspaceID: location.workspaceID },
+        }),
+      }),
+    )
+    if (response.status === 409) {
+      process.stderr.write(`Session already exists${EOL}`)
+      return
+    }
+    if (!response.ok) yield* Effect.fail(new Error(`Failed to import session: ${response.statusText}`))
+    const imported = yield* Schema.decodeUnknownEffect(
+      Schema.fromJsonString(Schema.Struct({ data: Session.Info })),
+    )(yield* Effect.promise(() => response.text()))
+    process.stdout.write(`Imported session: ${imported.data.id}${EOL}`)
+  }),
+)

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

@@ -10,11 +10,7 @@ export default Runtime.handler(Commands.commands.mini, (input) =>
     const { runMini, validateMiniTerminal } = yield* Effect.promise(() => import("../../mini"))
     yield* Effect.promise(async () => validateMiniTerminal())
     const serverURL = Option.getOrUndefined(input.server)
-    const server = yield* ServerConnection.resolve({
-      server: serverURL,
-      standalone: input.standalone,
-      mismatch: "replace",
-    })
+    const server = yield* ServerConnection.resolve({ server: serverURL, standalone: input.standalone })
     const config = yield* Config.Service
     const resolved = resolve(yield* config.get(), { terminalSuspend: process.platform !== "win32" })
     const fileSystem = yield* FileSystem.FileSystem

packages/cli/src/index.ts

@@ -22,7 +22,6 @@ const Handlers = Runtime.handlers(Commands, {
   },
   debug: {
     agents: () => import("./commands/handlers/debug/agents"),
-    config: () => import("./commands/handlers/debug/config"),
   },
   console: {
     login: () => import("./commands/handlers/console/login"),
@@ -37,6 +36,8 @@ const Handlers = Runtime.handlers(Commands, {
     list: () => import("./commands/handlers/plugin/list"),
   },
   models: () => import("./commands/handlers/models"),
+  export: () => import("./commands/handlers/export"),
+  import: () => import("./commands/handlers/import"),
   mini: () => import("./commands/handlers/mini"),
   run: () => import("./commands/handlers/run"),
   pair: () => import("./commands/handlers/pair"),

packages/cli/src/services/server-connection.ts

@@ -42,10 +42,9 @@ export const resolve = Effect.fn("cli.server-connection.resolve")(function* (arg
     return { endpoint: yield* Standalone.start() } satisfies Resolved
   }
 
-  const mismatch = args.mismatch ?? "ignore"
-  const options = yield* ServiceConfig.options({ checkVersion: mismatch !== "ignore" })
+  const options = yield* ServiceConfig.options()
   return {
-    endpoint: yield* resolveManaged({ ...options, onStart: args.onStart }, mismatch),
+    endpoint: yield* resolveManaged({ ...options, onStart: args.onStart }, args.mismatch ?? "replace"),
     service: managedService(options),
   } satisfies Resolved
 })

packages/cli/src/services/service-config.ts

@@ -98,12 +98,12 @@ const paths = Effect.gen(function* () {
   }
 })
 
-export const options = Effect.fnUntraced(function* (input: { readonly checkVersion?: boolean } = {}) {
+export const options = Effect.fnUntraced(function* () {
   const { file, legacyRegistrationFiles } = yield* paths
   yield* Effect.forEach(legacyRegistrationFiles, (legacy) => migrateRegistration(legacy, file))
   return {
     file,
-    version: input.checkVersion ? OPENCODE_VERSION : undefined,
+    version: OPENCODE_VERSION,
     command: [...selfCommand(), "serve", "--service"],
   }
 })

packages/cli/test/debug-config.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "node:fs/promises"
-import os from "node:os"
-import path from "node:path"
-import { OPENCODE_VERSION } from "../src/version"
-
-describe("debug config command", () => {
-  test("is included in troubleshooting help", async () => {
-    const [debug, config] = await Promise.all([cli(["debug", "--help"]), cli(["debug", "config", "--help"])])
-
-    expect(debug.exitCode).toBe(0)
-    expect(debug.stdout).toContain("config")
-    expect(debug.stdout).toContain("Show resolved configuration")
-    expect(config.exitCode).toBe(0)
-    expect(config.stdout).toContain("opencode debug config [flags]")
-  })
-
-  test("prints config entries from the invoking directory without reordering permissions", async () => {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-debug-config-"))
-    const project = path.join(import.meta.dir, "..")
-    const registration = path.join(root, "state", "opencode", "service-local.json")
-    const entries = [
-      {
-        type: "document",
-        path: path.join(project, "opencode.json"),
-        info: {
-          permissions: [
-            { action: "shell", resource: "*", effect: "ask" },
-            { action: "shell", resource: "git status", effect: "allow" },
-          ],
-        },
-      },
-      { type: "file", path: path.join(project, "opencode.json") },
-    ]
-    let requested: URL | undefined
-    const authorization: Array<string | null> = []
-    const server = Bun.serve({
-      port: 0,
-      fetch(request) {
-        const url = new URL(request.url)
-        if (url.pathname === "/api/health") {
-          return Response.json({ healthy: true, version: OPENCODE_VERSION, pid: process.pid })
-        }
-        requested = url
-        authorization.push(request.headers.get("authorization"))
-        return Response.json(entries)
-      },
-    })
-
-    try {
-      await fs.mkdir(path.dirname(registration), { recursive: true })
-      await fs.writeFile(
-        registration,
-        JSON.stringify({ version: OPENCODE_VERSION, url: server.url.toString(), pid: process.pid, password: "secret" }),
-      )
-      const result = await cli(["debug", "config"], project, { XDG_STATE_HOME: path.join(root, "state") })
-
-      expect({ exitCode: result.exitCode, stderr: result.stderr }).toEqual({ exitCode: 0, stderr: "" })
-      expect(JSON.parse(result.stdout)).toEqual(entries)
-      expect(requested?.pathname).toBe("/api/config")
-      expect(requested?.searchParams.get("location[directory]")).toBe(project)
-      expect(authorization).toEqual([`Basic ${btoa("opencode:secret")}`])
-    } finally {
-      server.stop(true)
-      await fs.rm(root, { recursive: true, force: true })
-    }
-  })
-})
-
-async function cli(args: string[], cwd = path.join(import.meta.dir, ".."), env?: Record<string, string>) {
-  const child = Bun.spawn([process.execPath, "run", path.join(import.meta.dir, "../src/index.ts"), ...args], {
-    cwd,
-    env: { ...process.env, ...env },
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(child.stdout).text(),
-    new Response(child.stderr).text(),
-    child.exited,
-  ])
-  return { stdout, stderr, exitCode }
-}

packages/cli/test/import-export.test.ts

@@ -0,0 +1,210 @@
+import { expect, test } from "bun:test"
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { OPENCODE_VERSION } from "../src/version"
+import { writeExport } from "../src/commands/handlers/export"
+
+const info = {
+  id: "ses_export_test",
+  projectID: "global",
+  cost: 0,
+  tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+  time: { created: 1, updated: 2 },
+  title: "Exported session",
+  location: { directory: "/project" },
+}
+const transfer = {
+  info,
+  messages: [
+    { id: "msg_first", type: "user", text: "First", time: { created: 1 } },
+    { id: "msg_second", type: "user", text: "Second", time: { created: 2 } },
+  ],
+}
+const sanitizedTransfer = {
+  info: {
+    ...info,
+    title: "[redacted:session-title:ses_export_test]",
+    location: { directory: "/[redacted:session-directory:ses_export_test]" },
+  },
+  messages: [
+    {
+      id: "msg_first",
+      type: "user",
+      text: "[redacted:text:msg_first]",
+      time: { created: 1 },
+    },
+    {
+      id: "msg_second",
+      type: "user",
+      text: "[redacted:text:msg_second]",
+      time: { created: 2 },
+    },
+  ],
+}
+
+const health = () => Response.json({ healthy: true, version: OPENCODE_VERSION, pid: process.pid })
+
+function run(args: string[], stdin?: string) {
+  const child = Bun.spawn([process.execPath, "run", "src/index.ts", ...args], {
+    cwd: path.join(import.meta.dir, ".."),
+    stdin: stdin === undefined ? undefined : new Blob([stdin]),
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  return Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited])
+}
+
+test("export is raw by default and supports explicit sanitization", async () => {
+  const sanitization: string[] = []
+  const server = Bun.serve({
+    port: 0,
+    fetch(request) {
+      const url = new URL(request.url)
+      if (url.pathname === "/api/health") return health()
+      if (url.pathname === `/api/session/${info.id}`) return Response.json({ data: info })
+      if (url.pathname === `/api/session/${info.id}/export`) {
+        sanitization.push(url.searchParams.get("sanitize") ?? "")
+        return Response.json({ data: url.searchParams.get("sanitize") === "true" ? sanitizedTransfer : transfer })
+      }
+      return new Response("Not found", { status: 404 })
+    },
+  })
+
+  try {
+    const [stdout, , exitCode] = await run(["export", "-s", info.id, "--server", server.url.toString()])
+    const exported = JSON.parse(stdout)
+
+    expect(exitCode).toBe(0)
+    expect(exported).toEqual(transfer)
+
+    const [sanitized, , sanitizedExitCode] = await run([
+      "export",
+      "-s",
+      info.id,
+      "--sanitize",
+      "--server",
+      server.url.toString(),
+    ])
+    expect(sanitizedExitCode).toBe(0)
+    expect(JSON.parse(sanitized)).toEqual(sanitizedTransfer)
+    expect(sanitization).toEqual(["false", "true"])
+  } finally {
+    await server.stop(true)
+  }
+}, 15_000)
+
+test("export reports an empty session list without a stack trace", async () => {
+  const server = Bun.serve({
+    port: 0,
+    fetch(request) {
+      const url = new URL(request.url)
+      if (url.pathname === "/api/health") return health()
+      if (url.pathname === "/api/location") {
+        return Response.json({
+          directory: "/project",
+          project: { id: "global", directory: "/project", canonical: "/project" },
+        })
+      }
+      if (url.pathname === "/api/session") return Response.json({ data: [], cursor: {} })
+      return new Response("Not found", { status: 404 })
+    },
+  })
+
+  try {
+    const [stdout, stderr, exitCode] = await run(["export", "--server", server.url.toString()])
+
+    expect(exitCode).toBe(0)
+    expect(stdout).toBe("")
+    expect(stderr).toBe(`No sessions found${os.EOL}`)
+  } finally {
+    await server.stop(true)
+  }
+})
+
+test("interactive export writes a temporary JSON file", async () => {
+  const output = await writeExport(transfer, info.id, false)
+  const file = output.trim()
+
+  try {
+    expect(path.dirname(file)).toBe(os.tmpdir())
+    expect(await Bun.file(file).json()).toEqual(transfer)
+  } finally {
+    await fs.rm(file, { force: true })
+  }
+})
+
+test("import validates a file and sends it to the resolved location", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-import-"))
+  const file = path.join(root, "session.json")
+  await fs.writeFile(file, JSON.stringify(transfer))
+  let imported: unknown
+  const server = Bun.serve({
+    port: 0,
+    async fetch(request) {
+      const url = new URL(request.url)
+      if (url.pathname === "/api/health") return health()
+      if (url.pathname === "/api/location") {
+        return Response.json({
+          directory: root,
+          project: { id: "global", directory: root, canonical: root },
+        })
+      }
+      if (url.pathname === "/api/session/import") {
+        imported = await request.json()
+        return Response.json({ data: { ...info, location: { directory: root } } })
+      }
+      return new Response("Not found", { status: 404 })
+    },
+  })
+
+  try {
+    const [stdout, , exitCode] = await run([
+      "import",
+      file,
+      "--directory",
+      root,
+      "--server",
+      server.url.toString(),
+    ])
+
+    expect(exitCode).toBe(0)
+    expect(stdout).toBe(`Imported session: ${info.id}${os.EOL}`)
+    expect(imported).toEqual({ ...transfer, location: { directory: root } })
+  } finally {
+    await server.stop(true)
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
+test("import reports an existing session without a stack trace", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-import-conflict-"))
+  const file = path.join(root, "session.json")
+  await fs.writeFile(file, JSON.stringify(transfer))
+  const server = Bun.serve({
+    port: 0,
+    fetch(request) {
+      const url = new URL(request.url)
+      if (url.pathname === "/api/health") return health()
+      if (url.pathname === "/api/location") {
+        return Response.json({
+          directory: root,
+          project: { id: "global", directory: root, canonical: root },
+        })
+      }
+      if (url.pathname === "/api/session/import") return new Response("Conflict", { status: 409 })
+      return new Response("Not found", { status: 404 })
+    },
+  })
+
+  try {
+    const [stdout, stderr, exitCode] = await run(["import", file, "--server", server.url.toString()])
+
+    expect(exitCode).toBe(0)
+    expect(stdout).toBe("")
+    expect(stderr).toBe(`Session already exists${os.EOL}`)
+  } finally {
+    await server.stop(true)
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})

packages/cli/test/server-connection.test.ts

@@ -55,17 +55,3 @@ test("resolution groups Effect-native lifecycle operations only for the managed
     await fs.rm(root, { recursive: true, force: true })
   }
 })
-
-test("service options only require a matching version when requested", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-options-"))
-  const layer = Global.layerWith({ config: path.join(root, "config"), state: path.join(root, "state") })
-  const runPromise = <A, E>(effect: Effect.Effect<A, E, Global.Service | FileSystem.FileSystem | Scope.Scope>) =>
-    Effect.runPromise(effect.pipe(Effect.provide(layer), Effect.provide(NodeFileSystem.layer), Effect.scoped))
-
-  try {
-    expect((await runPromise(ServiceConfig.options())).version).toBeUndefined()
-    expect((await runPromise(ServiceConfig.options({ checkVersion: true }))).version).toBe(OPENCODE_VERSION)
-  } finally {
-    await fs.rm(root, { recursive: true, force: true })
-  }
-})

packages/client/script/build.ts

@@ -8,7 +8,6 @@ import {
 } from "@opencode-ai/protocol/client"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Command } from "@opencode-ai/schema/command"
-import { Config } from "@opencode-ai/schema/config"
 import { Credential } from "@opencode-ai/schema/credential"
 import { Event } from "@opencode-ai/schema/event"
 import { EventLog } from "@opencode-ai/schema/event-log"
@@ -49,7 +48,6 @@ const effectContract = compile(ClientApi, { groupNames, omitEndpoints: effectOmi
 const effectTypeReferences = [
   ...namespaceTypes("Agent", "@opencode-ai/schema/agent", Agent),
   ...namespaceTypes("Command", "@opencode-ai/schema/command", Command),
-  ...namespaceTypes("Config", "@opencode-ai/schema/config", Config),
   ...namespaceTypes("Credential", "@opencode-ai/schema/credential", Credential),
   ...namespaceTypes("Event", "@opencode-ai/schema/event", Event),
   ...namespaceTypes("EventLog", "@opencode-ai/schema/event-log", EventLog),

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

@@ -38,7 +38,6 @@ import type { ProjectCopy } from "@opencode-ai/schema/project-copy"
 import type { Vcs } from "@opencode-ai/schema/vcs"
 import type { FileDiff } from "@opencode-ai/schema/file-diff"
 import type { WebSearch } from "@opencode-ai/schema/websearch"
-import type { Config } from "@opencode-ai/schema/config"
 
 export type Endpoint0_0Output = { readonly healthy: true; readonly version: string; readonly pid: number }
 export type HealthGetOperation<E = never> = () => Effect.Effect<Endpoint0_0Output, E>
@@ -127,42 +126,54 @@ export type Endpoint5_1Input = {
 export type Endpoint5_1Output = Session.Info
 export type SessionCreateOperation<E = never> = (input?: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>
 
-export type Endpoint5_2Output = { readonly [x: Session.ID]: { readonly type: "running" } }
-export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint5_2Output, E>
+export type Endpoint5_2Input = {
+  readonly info: Session.Info
+  readonly messages: ReadonlyArray<SessionMessage.Info>
+  readonly location?: Location.Ref | undefined
+}
+export type Endpoint5_2Output = Session.Info
+export type SessionImportOperation<E = never> = (input: Endpoint5_2Input) => Effect.Effect<Endpoint5_2Output, E>
 
-export type Endpoint5_3Input = { readonly sessionID: Session.ID }
-export type Endpoint5_3Output = Session.Info
-export type SessionGetOperation<E = never> = (input: Endpoint5_3Input) => Effect.Effect<Endpoint5_3Output, E>
+export type Endpoint5_3Input = { readonly sessionID: Session.ID; readonly sanitize?: boolean | undefined }
+export type Endpoint5_3Output = { readonly info: Session.Info; readonly messages: ReadonlyArray<SessionMessage.Info> }
+export type SessionExportOperation<E = never> = (input: Endpoint5_3Input) => Effect.Effect<Endpoint5_3Output, E>
 
-export type Endpoint5_4Input = { readonly sessionID: Session.ID }
-export type Endpoint5_4Output = void
-export type SessionRemoveOperation<E = never> = (input: Endpoint5_4Input) => Effect.Effect<Endpoint5_4Output, E>
+export type Endpoint5_4Output = { readonly [x: Session.ID]: { readonly type: "running" } }
+export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint5_4Output, E>
 
-export type Endpoint5_5Input = { readonly sessionID: Session.ID; readonly boundary: Session.ForkRequestBoundary }
+export type Endpoint5_5Input = { readonly sessionID: Session.ID }
 export type Endpoint5_5Output = Session.Info
-export type SessionForkOperation<E = never> = (input: Endpoint5_5Input) => Effect.Effect<Endpoint5_5Output, E>
+export type SessionGetOperation<E = never> = (input: Endpoint5_5Input) => Effect.Effect<Endpoint5_5Output, E>
 
-export type Endpoint5_6Input = { readonly sessionID: Session.ID; readonly agent: Agent.ID }
+export type Endpoint5_6Input = { readonly sessionID: Session.ID }
 export type Endpoint5_6Output = void
-export type SessionSwitchAgentOperation<E = never> = (input: Endpoint5_6Input) => Effect.Effect<Endpoint5_6Output, E>
+export type SessionRemoveOperation<E = never> = (input: Endpoint5_6Input) => Effect.Effect<Endpoint5_6Output, E>
 
-export type Endpoint5_7Input = { readonly sessionID: Session.ID; readonly model: Model.Ref }
-export type Endpoint5_7Output = void
-export type SessionSwitchModelOperation<E = never> = (input: Endpoint5_7Input) => Effect.Effect<Endpoint5_7Output, E>
+export type Endpoint5_7Input = { readonly sessionID: Session.ID; readonly boundary: Session.ForkRequestBoundary }
+export type Endpoint5_7Output = Session.Info
+export type SessionForkOperation<E = never> = (input: Endpoint5_7Input) => Effect.Effect<Endpoint5_7Output, E>
 
-export type Endpoint5_8Input = { readonly sessionID: Session.ID; readonly title: string }
+export type Endpoint5_8Input = { readonly sessionID: Session.ID; readonly agent: Agent.ID }
 export type Endpoint5_8Output = void
-export type SessionRenameOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>
+export type SessionSwitchAgentOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>
 
-export type Endpoint5_9Input = {
+export type Endpoint5_9Input = { readonly sessionID: Session.ID; readonly model: Model.Ref }
+export type Endpoint5_9Output = void
+export type SessionSwitchModelOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>
+
+export type Endpoint5_10Input = { readonly sessionID: Session.ID; readonly title: string }
+export type Endpoint5_10Output = void
+export type SessionRenameOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>
+
+export type Endpoint5_11Input = {
   readonly sessionID: Session.ID
   readonly directory: AbsolutePath
   readonly workspaceID?: Workspace.ID | undefined
 }
-export type Endpoint5_9Output = void
-export type SessionMoveOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>
+export type Endpoint5_11Output = void
+export type SessionMoveOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>
 
-export type Endpoint5_10Input = {
+export type Endpoint5_12Input = {
   readonly sessionID: Session.ID
   readonly id?: SessionMessage.ID | undefined
   readonly text: string
@@ -172,10 +183,10 @@ export type Endpoint5_10Input = {
   readonly delivery?: "steer" | "queue" | undefined
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_10Output = SessionPending.User
-export type SessionPromptOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>
+export type Endpoint5_12Output = SessionPending.User
+export type SessionPromptOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>
 
-export type Endpoint5_11Input = {
+export type Endpoint5_13Input = {
   readonly sessionID: Session.ID
   readonly id?: SessionMessage.ID | undefined
   readonly command: string
@@ -187,19 +198,19 @@ export type Endpoint5_11Input = {
   readonly delivery?: "steer" | "queue" | undefined
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_11Output = SessionPending.User
-export type SessionCommandOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>
+export type Endpoint5_13Output = SessionPending.User
+export type SessionCommandOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>
 
-export type Endpoint5_12Input = {
+export type Endpoint5_14Input = {
   readonly sessionID: Session.ID
   readonly id?: SessionMessage.ID | undefined
   readonly skill: Skill.ID
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_12Output = void
-export type SessionSkillOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>
+export type Endpoint5_14Output = void
+export type SessionSkillOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>
 
-export type Endpoint5_13Input = {
+export type Endpoint5_15Input = {
   readonly sessionID: Session.ID
   readonly id?: SessionMessage.ID | undefined
   readonly text: string
@@ -208,81 +219,81 @@ export type Endpoint5_13Input = {
   readonly delivery?: "steer" | "queue" | undefined
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_13Output = SessionPending.Synthetic
-export type SessionSyntheticOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>
+export type Endpoint5_15Output = SessionPending.Synthetic
+export type SessionSyntheticOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>
 
-export type Endpoint5_14Input = {
+export type Endpoint5_16Input = {
   readonly sessionID: Session.ID
   readonly id?: Event.ID | undefined
   readonly command: string
 }
-export type Endpoint5_14Output = void
-export type SessionShellOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>
-
-export type Endpoint5_15Input = { readonly sessionID: Session.ID; readonly id?: SessionMessage.ID | undefined }
-export type Endpoint5_15Output = SessionPending.Compaction
-export type SessionCompactOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>
-
-export type Endpoint5_16Input = { readonly sessionID: Session.ID }
 export type Endpoint5_16Output = void
-export type SessionWaitOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>
+export type SessionShellOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>
 
-export type Endpoint5_17Input = {
+export type Endpoint5_17Input = { readonly sessionID: Session.ID; readonly id?: SessionMessage.ID | undefined }
+export type Endpoint5_17Output = SessionPending.Compaction
+export type SessionCompactOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>
+
+export type Endpoint5_18Input = { readonly sessionID: Session.ID }
+export type Endpoint5_18Output = void
+export type SessionWaitOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>
+
+export type Endpoint5_19Input = {
   readonly sessionID: Session.ID
   readonly messageID: SessionMessage.ID
   readonly files?: boolean | undefined
 }
-export type Endpoint5_17Output = Session.Revert
-export type SessionRevertStageOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>
-
-export type Endpoint5_18Input = { readonly sessionID: Session.ID }
-export type Endpoint5_18Output = void
-export type SessionRevertClearOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>
-
-export type Endpoint5_19Input = { readonly sessionID: Session.ID }
-export type Endpoint5_19Output = void
-export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>
+export type Endpoint5_19Output = Session.Revert
+export type SessionRevertStageOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>
 
 export type Endpoint5_20Input = { readonly sessionID: Session.ID }
-export type Endpoint5_20Output = ReadonlyArray<SessionMessage.Info>
-export type SessionContextOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>
+export type Endpoint5_20Output = void
+export type SessionRevertClearOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>
 
 export type Endpoint5_21Input = { readonly sessionID: Session.ID }
-export type Endpoint5_21Output = ReadonlyArray<SessionPending.Info>
-export type SessionPendingListOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>
+export type Endpoint5_21Output = void
+export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>
 
 export type Endpoint5_22Input = { readonly sessionID: Session.ID }
-export type Endpoint5_22Output = ReadonlyArray<InstructionEntry.Info>
-export type SessionInstructionsEntryListOperation<E = never> = (
-  input: Endpoint5_22Input,
-) => Effect.Effect<Endpoint5_22Output, E>
+export type Endpoint5_22Output = ReadonlyArray<SessionMessage.Info>
+export type SessionContextOperation<E = never> = (input: Endpoint5_22Input) => Effect.Effect<Endpoint5_22Output, E>
 
-export type Endpoint5_23Input = {
+export type Endpoint5_23Input = { readonly sessionID: Session.ID }
+export type Endpoint5_23Output = ReadonlyArray<SessionPending.Info>
+export type SessionPendingListOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>
+
+export type Endpoint5_24Input = { readonly sessionID: Session.ID }
+export type Endpoint5_24Output = ReadonlyArray<InstructionEntry.Info>
+export type SessionInstructionsEntryListOperation<E = never> = (
+  input: Endpoint5_24Input,
+) => Effect.Effect<Endpoint5_24Output, E>
+
+export type Endpoint5_25Input = {
   readonly sessionID: Session.ID
   readonly key: InstructionEntry.Key
   readonly value: Schema.Json
 }
-export type Endpoint5_23Output = void
+export type Endpoint5_25Output = void
 export type SessionInstructionsEntryPutOperation<E = never> = (
-  input: Endpoint5_23Input,
-) => Effect.Effect<Endpoint5_23Output, E>
+  input: Endpoint5_25Input,
+) => Effect.Effect<Endpoint5_25Output, E>
 
-export type Endpoint5_24Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
-export type Endpoint5_24Output = void
+export type Endpoint5_26Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
+export type Endpoint5_26Output = void
 export type SessionInstructionsEntryRemoveOperation<E = never> = (
-  input: Endpoint5_24Input,
-) => Effect.Effect<Endpoint5_24Output, E>
+  input: Endpoint5_26Input,
+) => Effect.Effect<Endpoint5_26Output, E>
 
-export type Endpoint5_25Input = { readonly sessionID: Session.ID; readonly prompt: string }
-export type Endpoint5_25Output = { readonly text: string }
-export type SessionGenerateOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>
+export type Endpoint5_27Input = { readonly sessionID: Session.ID; readonly prompt: string }
+export type Endpoint5_27Output = { readonly text: string }
+export type SessionGenerateOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>
 
-export type Endpoint5_26Input = {
+export type Endpoint5_28Input = {
   readonly sessionID: Session.ID
   readonly after?: Event.Seq | undefined
   readonly follow?: boolean | undefined
 }
-export type Endpoint5_26Output =
+export type Endpoint5_28Output =
   | (
       | {
           readonly id: Event.ID
@@ -850,23 +861,25 @@ export type Endpoint5_26Output =
         }
     )
   | EventLog.Synced
-export type SessionLogOperation<E = never> = (input: Endpoint5_26Input) => Stream.Stream<Endpoint5_26Output, E>
+export type SessionLogOperation<E = never> = (input: Endpoint5_28Input) => Stream.Stream<Endpoint5_28Output, E>
 
-export type Endpoint5_27Input = { readonly sessionID: Session.ID }
-export type Endpoint5_27Output = void
-export type SessionInterruptOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>
+export type Endpoint5_29Input = { readonly sessionID: Session.ID }
+export type Endpoint5_29Output = void
+export type SessionInterruptOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>
 
-export type Endpoint5_28Input = { readonly sessionID: Session.ID }
-export type Endpoint5_28Output = void
-export type SessionBackgroundOperation<E = never> = (input: Endpoint5_28Input) => Effect.Effect<Endpoint5_28Output, E>
+export type Endpoint5_30Input = { readonly sessionID: Session.ID }
+export type Endpoint5_30Output = void
+export type SessionBackgroundOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>
 
-export type Endpoint5_29Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
-export type Endpoint5_29Output = SessionMessage.Info
-export type SessionMessageOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>
+export type Endpoint5_31Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
+export type Endpoint5_31Output = SessionMessage.Info
+export type SessionMessageOperation<E = never> = (input: Endpoint5_31Input) => Effect.Effect<Endpoint5_31Output, E>
 
 export interface SessionApi<E = never> {
   readonly list: SessionListOperation<E>
   readonly create: SessionCreateOperation<E>
+  readonly import: SessionImportOperation<E>
+  readonly export: SessionExportOperation<E>
   readonly active: SessionActiveOperation<E>
   readonly get: SessionGetOperation<E>
   readonly remove: SessionRemoveOperation<E>
@@ -1596,16 +1609,6 @@ export interface WebsearchApi<E = never> {
   readonly query: WebsearchQueryOperation<E>
 }
 
-export type Endpoint29_0Input = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-}
-export type Endpoint29_0Output = ReadonlyArray<Config.Entry>
-export type ConfigGetOperation<E = never> = (input?: Endpoint29_0Input) => Effect.Effect<Endpoint29_0Output, E>
-
-export interface ConfigApi<E = never> {
-  readonly get: ConfigGetOperation<E>
-}
-
 export interface AppApi<E = never> {
   readonly health: HealthApi<E>
   readonly server: ServerApi<E>
@@ -1636,5 +1639,4 @@ export interface AppApi<E = never> {
   readonly debug: DebugApi<E>
   readonly migration: MigrationApi<E>
   readonly websearch: WebsearchApi<E>
-  readonly config: ConfigApi<E>
 }

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

@@ -21,10 +21,10 @@ import type {
   Endpoint5_0Output,
   Endpoint5_1Input,
   Endpoint5_1Output,
+  Endpoint5_2Input,
   Endpoint5_2Output,
   Endpoint5_3Input,
   Endpoint5_3Output,
-  Endpoint5_4Input,
   Endpoint5_4Output,
   Endpoint5_5Input,
   Endpoint5_5Output,
@@ -76,6 +76,10 @@ import type {
   Endpoint5_28Output,
   Endpoint5_29Input,
   Endpoint5_29Output,
+  Endpoint5_30Input,
+  Endpoint5_30Output,
+  Endpoint5_31Input,
+  Endpoint5_31Output,
   Endpoint6_0Input,
   Endpoint6_0Output,
   Endpoint7_0Input,
@@ -220,8 +224,6 @@ import type {
   Endpoint28_0Output,
   Endpoint28_1Input,
   Endpoint28_1Output,
-  Endpoint29_0Input,
-  Endpoint29_0Output,
 } from "../api/api.js"
 import { ClientError } from "./client-error"
 
@@ -317,9 +319,11 @@ const Endpoint5_1 = (raw: RawClient["server.session"]) => (input?: Endpoint5_1In
     ),
   )
 
-const Endpoint5_2 = (raw: RawClient["server.session"]) => () =>
+const Endpoint5_2 = (raw: RawClient["server.session"]) => (input: Endpoint5_2Input) =>
   preserveEffect<Endpoint5_2Output>()(
-    raw["session.active"]({}).pipe(
+    raw["session.import"]({
+      payload: { info: input["info"], messages: input["messages"], location: input["location"] },
+    }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
@@ -327,20 +331,23 @@ const Endpoint5_2 = (raw: RawClient["server.session"]) => () =>
 
 const Endpoint5_3 = (raw: RawClient["server.session"]) => (input: Endpoint5_3Input) =>
   preserveEffect<Endpoint5_3Output>()(
-    raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    raw["session.export"]({ params: { sessionID: input["sessionID"] }, query: { sanitize: input["sanitize"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
-const Endpoint5_4 = (raw: RawClient["server.session"]) => (input: Endpoint5_4Input) =>
+const Endpoint5_4 = (raw: RawClient["server.session"]) => () =>
   preserveEffect<Endpoint5_4Output>()(
-    raw["session.remove"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
+    raw["session.active"]({}).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
   )
 
 const Endpoint5_5 = (raw: RawClient["server.session"]) => (input: Endpoint5_5Input) =>
   preserveEffect<Endpoint5_5Output>()(
-    raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { boundary: input["boundary"] } }).pipe(
+    raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
@@ -348,35 +355,48 @@ const Endpoint5_5 = (raw: RawClient["server.session"]) => (input: Endpoint5_5Inp
 
 const Endpoint5_6 = (raw: RawClient["server.session"]) => (input: Endpoint5_6Input) =>
   preserveEffect<Endpoint5_6Output>()(
-    raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
+    raw["session.remove"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
 const Endpoint5_7 = (raw: RawClient["server.session"]) => (input: Endpoint5_7Input) =>
   preserveEffect<Endpoint5_7Output>()(
-    raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(
+    raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { boundary: input["boundary"] } }).pipe(
       Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
     ),
   )
 
 const Endpoint5_8 = (raw: RawClient["server.session"]) => (input: Endpoint5_8Input) =>
   preserveEffect<Endpoint5_8Output>()(
-    raw["session.rename"]({ params: { sessionID: input["sessionID"] }, payload: { title: input["title"] } }).pipe(
+    raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
 const Endpoint5_9 = (raw: RawClient["server.session"]) => (input: Endpoint5_9Input) =>
   preserveEffect<Endpoint5_9Output>()(
+    raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(
+      Effect.mapError(mapClientError),
+    ),
+  )
+
+const Endpoint5_10 = (raw: RawClient["server.session"]) => (input: Endpoint5_10Input) =>
+  preserveEffect<Endpoint5_10Output>()(
+    raw["session.rename"]({ params: { sessionID: input["sessionID"] }, payload: { title: input["title"] } }).pipe(
+      Effect.mapError(mapClientError),
+    ),
+  )
+
+const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11Input) =>
+  preserveEffect<Endpoint5_11Output>()(
     raw["session.move"]({
       params: { sessionID: input["sessionID"] },
       payload: { directory: input["directory"], workspaceID: input["workspaceID"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_10 = (raw: RawClient["server.session"]) => (input: Endpoint5_10Input) =>
-  preserveEffect<Endpoint5_10Output>()(
+const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12Input) =>
+  preserveEffect<Endpoint5_12Output>()(
     raw["session.prompt"]({
       params: { sessionID: input["sessionID"] },
       payload: {
@@ -394,8 +414,8 @@ const Endpoint5_10 = (raw: RawClient["server.session"]) => (input: Endpoint5_10I
     ),
   )
 
-const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11Input) =>
-  preserveEffect<Endpoint5_11Output>()(
+const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13Input) =>
+  preserveEffect<Endpoint5_13Output>()(
     raw["session.command"]({
       params: { sessionID: input["sessionID"] },
       payload: {
@@ -415,16 +435,16 @@ const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11I
     ),
   )
 
-const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12Input) =>
-  preserveEffect<Endpoint5_12Output>()(
+const Endpoint5_14 = (raw: RawClient["server.session"]) => (input: Endpoint5_14Input) =>
+  preserveEffect<Endpoint5_14Output>()(
     raw["session.skill"]({
       params: { sessionID: input["sessionID"] },
       payload: { id: input["id"], skill: input["skill"], resume: input["resume"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13Input) =>
-  preserveEffect<Endpoint5_13Output>()(
+const Endpoint5_15 = (raw: RawClient["server.session"]) => (input: Endpoint5_15Input) =>
+  preserveEffect<Endpoint5_15Output>()(
     raw["session.synthetic"]({
       params: { sessionID: input["sessionID"] },
       payload: {
@@ -441,29 +461,29 @@ const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13I
     ),
   )
 
-const Endpoint5_14 = (raw: RawClient["server.session"]) => (input: Endpoint5_14Input) =>
-  preserveEffect<Endpoint5_14Output>()(
+const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16Input) =>
+  preserveEffect<Endpoint5_16Output>()(
     raw["session.shell"]({
       params: { sessionID: input["sessionID"] },
       payload: { id: input["id"], command: input["command"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_15 = (raw: RawClient["server.session"]) => (input: Endpoint5_15Input) =>
-  preserveEffect<Endpoint5_15Output>()(
+const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17Input) =>
+  preserveEffect<Endpoint5_17Output>()(
     raw["session.compact"]({ params: { sessionID: input["sessionID"] }, payload: { id: input["id"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
-const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16Input) =>
-  preserveEffect<Endpoint5_16Output>()(
+const Endpoint5_18 = (raw: RawClient["server.session"]) => (input: Endpoint5_18Input) =>
+  preserveEffect<Endpoint5_18Output>()(
     raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17Input) =>
-  preserveEffect<Endpoint5_17Output>()(
+const Endpoint5_19 = (raw: RawClient["server.session"]) => (input: Endpoint5_19Input) =>
+  preserveEffect<Endpoint5_19Output>()(
     raw["session.revert.stage"]({
       params: { sessionID: input["sessionID"] },
       payload: { messageID: input["messageID"], files: input["files"] },
@@ -473,35 +493,19 @@ const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17I
     ),
   )
 
-const Endpoint5_18 = (raw: RawClient["server.session"]) => (input: Endpoint5_18Input) =>
-  preserveEffect<Endpoint5_18Output>()(
-    raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
-  )
-
-const Endpoint5_19 = (raw: RawClient["server.session"]) => (input: Endpoint5_19Input) =>
-  preserveEffect<Endpoint5_19Output>()(
-    raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
-  )
-
 const Endpoint5_20 = (raw: RawClient["server.session"]) => (input: Endpoint5_20Input) =>
   preserveEffect<Endpoint5_20Output>()(
-    raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
-      Effect.mapError(mapClientError),
-      Effect.map((value) => value.data),
-    ),
+    raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
 const Endpoint5_21 = (raw: RawClient["server.session"]) => (input: Endpoint5_21Input) =>
   preserveEffect<Endpoint5_21Output>()(
-    raw["session.pending.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
-      Effect.mapError(mapClientError),
-      Effect.map((value) => value.data),
-    ),
+    raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
 const Endpoint5_22 = (raw: RawClient["server.session"]) => (input: Endpoint5_22Input) =>
   preserveEffect<Endpoint5_22Output>()(
-    raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
@@ -509,29 +513,45 @@ const Endpoint5_22 = (raw: RawClient["server.session"]) => (input: Endpoint5_22I
 
 const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23Input) =>
   preserveEffect<Endpoint5_23Output>()(
+    raw["session.pending.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint5_24 = (raw: RawClient["server.session"]) => (input: Endpoint5_24Input) =>
+  preserveEffect<Endpoint5_24Output>()(
+    raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
+  preserveEffect<Endpoint5_25Output>()(
     raw["session.instructions.entry.put"]({
       params: { sessionID: input["sessionID"], key: input["key"] },
       payload: { value: input["value"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_24 = (raw: RawClient["server.session"]) => (input: Endpoint5_24Input) =>
-  preserveEffect<Endpoint5_24Output>()(
+const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
+  preserveEffect<Endpoint5_26Output>()(
     raw["session.instructions.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
-const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
-  preserveEffect<Endpoint5_25Output>()(
+const Endpoint5_27 = (raw: RawClient["server.session"]) => (input: Endpoint5_27Input) =>
+  preserveEffect<Endpoint5_27Output>()(
     raw["session.generate"]({ params: { sessionID: input["sessionID"] }, payload: { prompt: input["prompt"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
-const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
-  preserveStream<Endpoint5_26Output>()(
+const Endpoint5_28 = (raw: RawClient["server.session"]) => (input: Endpoint5_28Input) =>
+  preserveStream<Endpoint5_28Output>()(
     Stream.unwrap(
       raw["session.log"]({
         params: { sessionID: input["sessionID"] },
@@ -543,18 +563,18 @@ const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26I
     ),
   )
 
-const Endpoint5_27 = (raw: RawClient["server.session"]) => (input: Endpoint5_27Input) =>
-  preserveEffect<Endpoint5_27Output>()(
+const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29Input) =>
+  preserveEffect<Endpoint5_29Output>()(
     raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_28 = (raw: RawClient["server.session"]) => (input: Endpoint5_28Input) =>
-  preserveEffect<Endpoint5_28Output>()(
+const Endpoint5_30 = (raw: RawClient["server.session"]) => (input: Endpoint5_30Input) =>
+  preserveEffect<Endpoint5_30Output>()(
     raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29Input) =>
-  preserveEffect<Endpoint5_29Output>()(
+const Endpoint5_31 = (raw: RawClient["server.session"]) => (input: Endpoint5_31Input) =>
+  preserveEffect<Endpoint5_31Output>()(
     raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
@@ -564,30 +584,32 @@ const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29I
 const adaptGroup5 = (raw: RawClient["server.session"]) => ({
   list: Endpoint5_0(raw),
   create: Endpoint5_1(raw),
-  active: Endpoint5_2(raw),
-  get: Endpoint5_3(raw),
-  remove: Endpoint5_4(raw),
-  fork: Endpoint5_5(raw),
-  switchAgent: Endpoint5_6(raw),
-  switchModel: Endpoint5_7(raw),
-  rename: Endpoint5_8(raw),
-  move: Endpoint5_9(raw),
-  prompt: Endpoint5_10(raw),
-  command: Endpoint5_11(raw),
-  skill: Endpoint5_12(raw),
-  synthetic: Endpoint5_13(raw),
-  shell: Endpoint5_14(raw),
-  compact: Endpoint5_15(raw),
-  wait: Endpoint5_16(raw),
-  revert: { stage: Endpoint5_17(raw), clear: Endpoint5_18(raw), commit: Endpoint5_19(raw) },
-  context: Endpoint5_20(raw),
-  pending: { list: Endpoint5_21(raw) },
-  instructions: { entry: { list: Endpoint5_22(raw), put: Endpoint5_23(raw), remove: Endpoint5_24(raw) } },
-  generate: Endpoint5_25(raw),
-  log: Endpoint5_26(raw),
-  interrupt: Endpoint5_27(raw),
-  background: Endpoint5_28(raw),
-  message: Endpoint5_29(raw),
+  import: Endpoint5_2(raw),
+  export: Endpoint5_3(raw),
+  active: Endpoint5_4(raw),
+  get: Endpoint5_5(raw),
+  remove: Endpoint5_6(raw),
+  fork: Endpoint5_7(raw),
+  switchAgent: Endpoint5_8(raw),
+  switchModel: Endpoint5_9(raw),
+  rename: Endpoint5_10(raw),
+  move: Endpoint5_11(raw),
+  prompt: Endpoint5_12(raw),
+  command: Endpoint5_13(raw),
+  skill: Endpoint5_14(raw),
+  synthetic: Endpoint5_15(raw),
+  shell: Endpoint5_16(raw),
+  compact: Endpoint5_17(raw),
+  wait: Endpoint5_18(raw),
+  revert: { stage: Endpoint5_19(raw), clear: Endpoint5_20(raw), commit: Endpoint5_21(raw) },
+  context: Endpoint5_22(raw),
+  pending: { list: Endpoint5_23(raw) },
+  instructions: { entry: { list: Endpoint5_24(raw), put: Endpoint5_25(raw), remove: Endpoint5_26(raw) } },
+  generate: Endpoint5_27(raw),
+  log: Endpoint5_28(raw),
+  interrupt: Endpoint5_29(raw),
+  background: Endpoint5_30(raw),
+  message: Endpoint5_31(raw),
 })
 
 const Endpoint6_0 = (raw: RawClient["server.message"]) => (input: Endpoint6_0Input) =>
@@ -1243,13 +1265,6 @@ const adaptGroup28 = (raw: RawClient["server.websearch"]) => ({
   query: Endpoint28_1(raw),
 })
 
-const Endpoint29_0 = (raw: RawClient["server.config"]) => (input?: Endpoint29_0Input) =>
-  preserveEffect<Endpoint29_0Output>()(
-    raw["config.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
-  )
-
-const adaptGroup29 = (raw: RawClient["server.config"]) => ({ get: Endpoint29_0(raw) })
-
 const adaptClient = (raw: RawClient) => ({
   health: adaptGroup0(raw["server.health"]),
   server: adaptGroup1(raw["server.server"]),
@@ -1280,7 +1295,6 @@ const adaptClient = (raw: RawClient) => ({
   debug: adaptGroup26(raw["server.debug"]),
   migration: adaptGroup27(raw["server.migration"]),
   websearch: adaptGroup28(raw["server.websearch"]),
-  config: adaptGroup29(raw["server.config"]),
 })
 
 export const make = (options?: { readonly baseUrl?: URL | string }) =>

packages/client/src/effect/index.ts

@@ -8,7 +8,6 @@ export type {
   AppApi,
   CatalogApi,
   CommandApi,
-  ConfigApi,
   EventApi,
   IntegrationApi,
   ModelApi,
@@ -21,7 +20,6 @@ export type {
 } from "./api.js"
 export { Agent } from "@opencode-ai/schema/agent"
 export { Command } from "@opencode-ai/schema/command"
-export { Config } from "@opencode-ai/schema/config"
 export { Credential } from "@opencode-ai/schema/credential"
 export { Event } from "@opencode-ai/schema/event"
 export { EventLog } from "@opencode-ai/schema/event-log"

packages/client/src/effect/service.ts

@@ -53,7 +53,6 @@ const discoverLocal = Effect.fnUntraced(function* (options: DiscoverOptions) {
 /** Ensure a healthy, compatible local service is running. */
 export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOptions = {}) {
   const contenders = new Set<Contender>()
-  let timeouts: { readonly info: Info; readonly count: number } | undefined
   let announced = false
   let lastSpawn = 0
   let spawnDelay = 5_000
@@ -83,18 +82,6 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
     const registration = yield* registered(options.file, true)
     const info = registration.info
     const service = registration.service
-    if (registration.timedOut && info !== undefined) {
-      timeouts = {
-        info,
-        count: timeouts !== undefined && same(timeouts.info, info) ? timeouts.count + 1 : 1,
-      }
-      if (timeouts.count >= 3) {
-        yield* announce("missing")
-        yield* evict(info, options)
-        timeouts = undefined
-        lastSpawn = Date.now() - spawnDelay
-      }
-    } else timeouts = undefined
     if (service !== undefined) {
       spawnDelay = 5_000
       const compatible = !service.legacy && (options.version === undefined || service.version === options.version)
@@ -195,10 +182,6 @@ type LocalService = {
 }
 
 const probe = Effect.fnUntraced(function* (info: Info, allowLegacy = false) {
-  return (yield* probeResult(info, allowLegacy)).service
-})
-
-const probeResult = Effect.fnUntraced(function* (info: Info, allowLegacy = false) {
   const endpoint = {
     url: info.url,
     auth:
@@ -206,53 +189,39 @@ const probeResult = Effect.fnUntraced(function* (info: Info, allowLegacy = false
         ? undefined
         : { type: "basic" as const, username: "opencode", password: info.password },
   } satisfies Endpoint
-  const signal = AbortSignal.timeout(2_000)
-  const result = yield* Effect.promise(() =>
+  const response = yield* Effect.tryPromise(() =>
     fetch(new URL("/api/health", info.url), {
       headers: headers(endpoint),
-      signal,
-    })
-      .then(async (response) => ({ response, body: (await response.json()) as unknown }))
-      .then(
-        (value) => ({ value }),
-        (cause: unknown) => ({ cause }),
-      ),
-  )
-  if ("cause" in result) return { service: undefined, timedOut: signal.aborted }
-  const response = result.value.response
-  const body = result.value.body
+      signal: AbortSignal.timeout(2_000),
+    }),
+  ).pipe(Effect.option, Effect.map(Option.getOrUndefined))
+  if (response === undefined) return undefined
+  const body = yield* Effect.tryPromise(() => response.json()).pipe(Effect.option, Effect.map(Option.getOrUndefined))
   const health = decodeHealth(body)
   if (Option.isSome(health)) {
-    if (health.value.pid !== info.pid) return { service: undefined, timedOut: false }
-    if (info.version !== undefined && health.value.version !== info.version)
-      return { service: undefined, timedOut: false }
+    if (health.value.pid !== info.pid) return undefined
+    if (info.version !== undefined && health.value.version !== info.version) return undefined
     return {
-      service: {
-        info,
-        endpoint,
-        version: health.value.version,
-        state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
-        legacy: false,
-      } satisfies LocalService,
-      timedOut: false,
-    }
+      info,
+      endpoint,
+      version: health.value.version,
+      state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
+      legacy: false,
+    } satisfies LocalService
   }
   if (
     !allowLegacy ||
     Option.isNone(decodeLegacyHealth(body)) ||
     (typeof body === "object" && body !== null && ("version" in body || "pid" in body))
   )
-    return { service: undefined, timedOut: false }
-  return {
-    service: { info, endpoint, state: "ready", legacy: true } satisfies LocalService,
-    timedOut: false,
-  }
+    return undefined
+  return { info, endpoint, state: "ready", legacy: true } satisfies LocalService
 })
 
 const registered = Effect.fnUntraced(function* (file?: string, allowLegacy = false) {
   const info = yield* read(file)
-  if (info === undefined) return { info: undefined, service: undefined, timedOut: false }
-  return { info, ...(yield* probeResult(info, allowLegacy)) }
+  if (info === undefined) return { info: undefined, service: undefined }
+  return { info, service: yield* probe(info, allowLegacy) }
 })
 
 // Health-checked lookup without the version gate: lifecycle operations must be
@@ -280,19 +249,6 @@ function same(left: Info, right: Info) {
   return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
 }
 
-const evict = Effect.fnUntraced(function* (info: Info, options: { readonly file?: string }) {
-  const current = yield* read(options.file)
-  if (current === undefined || !same(current, info)) return
-  yield* signal(info.pid, "SIGTERM")
-  const done = yield* stopped(info.pid).pipe(Effect.retry(poll), Effect.option)
-  if (Option.isSome(done)) return
-
-  const latest = yield* read(options.file)
-  if (latest === undefined || !same(latest, info)) return
-  yield* signal(info.pid, "SIGKILL")
-  yield* stopped(info.pid).pipe(Effect.retry(poll))
-})
-
 const kill = Effect.fnUntraced(function* (service: LocalService, options: { readonly file?: string }) {
   const requested = yield* requestStop(service)
   if (requested === "rejected") return

packages/client/src/promise/api.ts

@@ -2,7 +2,6 @@ type Client = ReturnType<typeof import("./generated/client.js").make>
 
 export type AgentApi = Client["agent"]
 export type CommandApi = Client["command"]
-export type ConfigApi = Client["config"]
 export type EventApi = Client["event"]
 export type IntegrationApi = Client["integration"]
 export type ModelApi = Client["model"]

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

@@ -15,6 +15,10 @@ import type {
   SessionListOutput,
   SessionCreateInput,
   SessionCreateOutput,
+  SessionImportInput,
+  SessionImportOutput,
+  SessionExportInput,
+  SessionExportOutput,
   SessionActiveOutput,
   SessionGetInput,
   SessionGetOutput,
@@ -216,8 +220,6 @@ import type {
   WebsearchProvidersOutput,
   WebsearchQueryInput,
   WebsearchQueryOutput,
-  ConfigGetInput,
-  ConfigGetOutput,
 } from "./types"
 import { ClientError } from "./client-error"
 
@@ -478,6 +480,30 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
+      import: (input: SessionImportInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionImportOutput }>(
+          {
+            method: "POST",
+            path: `/api/session/import`,
+            body: { info: input["info"], messages: input["messages"], location: input["location"] },
+            successStatus: 200,
+            declaredStatuses: [409, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      export: (input: SessionExportInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionExportOutput }>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/export`,
+            query: { sanitize: input["sanitize"] },
+            successStatus: 200,
+            declaredStatuses: [404, 500, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
       active: (requestOptions?: RequestOptions) =>
         request<{ readonly data: SessionActiveOutput }>(
           {
@@ -1813,20 +1839,6 @@ export function make(options: ClientOptions) {
           requestOptions,
         ),
     },
-    config: {
-      get: (input?: ConfigGetInput, requestOptions?: RequestOptions) =>
-        request<ConfigGetOutput>(
-          {
-            method: "GET",
-            path: `/api/config`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
   }
 }
 

packages/client/src/promise/index.ts

@@ -3,7 +3,6 @@ export type {
   AgentApi,
   CatalogApi,
   CommandApi,
-  ConfigApi,
   EventApi,
   IntegrationApi,
   ModelApi,

packages/client/src/promise/service.ts

@@ -34,7 +34,6 @@ async function discoverLocal(options: DiscoverOptions) {
 export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
   const deadline = Date.now() + 120_000
   const contenders = new Set<Contender>()
-  let timeouts: { readonly info: Info; readonly count: number } | undefined
   let announced = false
   let lastSpawn = 0
   let spawnDelay = 5_000
@@ -63,19 +62,6 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
   while (true) {
     if (Date.now() >= deadline) throw new Error("Timed out waiting for the background service to start")
     const registration = await registered(options.file, true)
-    if (registration.timedOut && registration.info !== undefined) {
-      timeouts = {
-        info: registration.info,
-        count:
-          timeouts !== undefined && same(timeouts.info, registration.info) ? timeouts.count + 1 : 1,
-      }
-      if (timeouts.count >= 3) {
-        announce("missing")
-        await evict(registration.info, options)
-        timeouts = undefined
-        lastSpawn = Date.now() - spawnDelay
-      }
-    } else timeouts = undefined
 
     if (registration.service !== undefined) {
       spawnDelay = 5_000
@@ -159,10 +145,6 @@ type LocalService = {
 }
 
 async function probe(info: Info, allowLegacy = false): Promise<LocalService | undefined> {
-  return (await probeResult(info, allowLegacy)).service
-}
-
-async function probeResult(info: Info, allowLegacy = false) {
   const endpoint = {
     url: info.url,
     auth:
@@ -170,48 +152,30 @@ async function probeResult(info: Info, allowLegacy = false) {
         ? undefined
         : { type: "basic" as const, username: "opencode", password: info.password },
   } satisfies Endpoint
-  const signal = AbortSignal.timeout(2_000)
-  const result = await fetch(new URL("/api/health", info.url), {
+  const response = await fetch(new URL("/api/health", info.url), {
     headers: headers(endpoint),
-    signal,
-  })
-    .then(async (response) => ({
-      response,
-      body: (await response.json()) as ServiceHealth | { readonly healthy: true },
-    }))
-    .then(
-      (value) => ({ value }),
-      (cause: unknown) => ({ cause }),
-    )
-  if ("cause" in result) return { service: undefined, timedOut: signal.aborted }
-  const response = result.value.response
-  const body = result.value.body
+    signal: AbortSignal.timeout(2_000),
+  }).catch(() => undefined)
+  const body = (await response?.json().catch(() => undefined)) as ServiceHealth | { readonly healthy: true } | undefined
   if (body !== undefined && "version" in body && "pid" in body) {
-    if (body.pid !== info.pid) return { service: undefined, timedOut: false }
-    if (info.version !== undefined && body.version !== info.version)
-      return { service: undefined, timedOut: false }
+    if (body.pid !== info.pid) return undefined
+    if (info.version !== undefined && body.version !== info.version) return undefined
     return {
-      service: {
-        info,
-        endpoint,
-        version: body.version,
-        state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
-        legacy: false,
-      } satisfies LocalService,
-      timedOut: false,
+      info,
+      endpoint,
+      version: body.version,
+      state: response?.ok ? "ready" : response?.status === 500 ? "failed" : "waiting",
+      legacy: false,
     }
   }
-  if (!allowLegacy || body?.healthy !== true) return { service: undefined, timedOut: false }
-  return {
-    service: { info, endpoint, state: "ready", legacy: true } satisfies LocalService,
-    timedOut: false,
-  }
+  if (!allowLegacy || body?.healthy !== true) return undefined
+  return { info, endpoint, state: "ready", legacy: true }
 }
 
 async function registered(file?: string, allowLegacy = false) {
   const info = await read(file)
-  if (info === undefined) return { info: undefined, service: undefined, timedOut: false }
-  return { info, ...(await probeResult(info, allowLegacy)) }
+  if (info === undefined) return { info: undefined, service: undefined }
+  return { info, service: await probe(info, allowLegacy) }
 }
 
 async function find(options: { readonly file?: string }) {
@@ -245,18 +209,6 @@ function same(left: Info, right: Info) {
   return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
 }
 
-async function evict(info: Info, options: { readonly file?: string }) {
-  const current = await read(options.file)
-  if (current === undefined || !same(current, info)) return
-  signal(info.pid, "SIGTERM")
-  if (await waitUntilStopped(info.pid)) return
-
-  const latest = await read(options.file)
-  if (latest === undefined || !same(latest, info)) return
-  signal(info.pid, "SIGKILL")
-  if (!(await waitUntilStopped(info.pid))) throw new Error(`Server process ${info.pid} is still running`)
-}
-
 async function kill(service: LocalService, options: { readonly file?: string }) {
   const requested = await requestStop(service)
   if (requested === "rejected") return

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

@@ -1,7 +1,6 @@
 import { expect, test } from "bun:test"
 import { Schema } from "effect"
 import { Agent } from "@opencode-ai/schema/agent"
-import { Config } from "@opencode-ai/schema/config"
 import { Model } from "@opencode-ai/schema/model"
 import { Prompt } from "@opencode-ai/schema/prompt"
 import { Session } from "@opencode-ai/schema/session"
@@ -11,7 +10,6 @@ const Client = await import("../src/effect")
 
 test("effect entrypoint exposes canonical Schema contracts", () => {
   expect(Client.Agent).toBe(Agent)
-  expect(Client.Config).toBe(Config)
   expect(Client.Model).toBe(Model)
   expect(Client.Session).toBe(Session)
 })

packages/client/test/fixture/service.ts

@@ -47,10 +47,6 @@ const server = Bun.serve({
     }
     if (pathname !== "/api/health") return new Response(null, { status: 404 })
     requests += 1
-    if (mode === "hanging") {
-      await appendFile(registration + ".requests", process.pid + "\n")
-      return new Promise<Response>(() => {})
-    }
     if (mode === "modern" && requests === 1) {
       await writeFile(registration + ".first-request", "")
       while (!(await Bun.file(registration + ".release").exists())) await Bun.sleep(5)

packages/client/test/promise-service.test.ts

@@ -70,32 +70,6 @@ test("reports a failed registered service", async () => {
   )
 })
 
-test("evicts an unresponsive registered service before starting its replacement", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const existing = Bun.spawn([process.execPath, fixture, registration, "hanging"], {
-    stdout: "ignore",
-    stderr: "inherit",
-  })
-  processes.push(existing)
-  await waitForFile(registration)
-  const original = await Bun.file(registration).json()
-
-  const endpoint = await Service.ensure({
-    file: registration,
-    version: "test",
-    command: [process.execPath, fixture, registration, "delayed", "10"],
-  })
-  const replacement = await Bun.file(registration).json()
-
-  expect((await Bun.file(registration + ".requests").text()).trim().split("\n")).toHaveLength(3)
-  expect(await existing.exited).toBe(0)
-  expect(replacement.pid).not.toBe(original.pid)
-  expect(endpoint.url).toBe(replacement.url)
-  process.kill(replacement.pid, "SIGTERM")
-  await waitForExit(replacement.pid)
-}, 20_000)
-
 test("requests graceful stop of the exact service instance", async () => {
   const registration = await setup("graceful")
   const info = await Bun.file(registration).json()

packages/client/test/promise.test.ts

@@ -33,7 +33,6 @@ test("exposes every standard HTTP API group", () => {
     "vcs",
     "debug",
     "websearch",
-    "config",
   ])
   expect(Object.keys(client.debug)).toEqual(["location"])
   expect(Object.keys(client.debug.location)).toEqual(["list", "evict"])
@@ -51,34 +50,6 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])
 })
 
-test("config.get returns ordered config entries for a location", async () => {
-  let request: Request | undefined
-  const entries = [
-    {
-      type: "document" as const,
-      path: "/tmp/project/opencode.json",
-      info: {
-        permissions: [
-          { action: "shell", resource: "*", effect: "ask" as const },
-          { action: "shell", resource: "git status", effect: "allow" as const },
-        ],
-      },
-    },
-    { type: "file" as const, path: "/tmp/project/opencode.json" },
-  ]
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input) => {
-      request = input instanceof Request ? input : new Request(input)
-      return Response.json(entries)
-    },
-  })
-
-  expect(await client.config.get({ location: { directory: "/tmp/project" } })).toEqual(entries)
-  expect(request?.method).toBe("GET")
-  expect(request?.url).toBe("http://localhost:3000/api/config?location%5Bdirectory%5D=%2Ftmp%2Fproject")
-})
-
 test("websearch.query uses the public HTTP contract", async () => {
   let request: Request | undefined
   const client = OpenCode.make({

packages/client/test/service.test.ts

@@ -70,30 +70,6 @@ test("reports a failed registered service without spawning", async () => {
   expect(process.exitCode).toBe(null)
 })
 
-test("evicts an unresponsive registered service before starting its replacement", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const existing = spawn(registration, "hanging")
-  await waitForFile(registration)
-  const original = await Bun.file(registration).json()
-
-  const endpoint = await run(
-    Service.ensure({
-      file: registration,
-      version: "test",
-      command: [process.execPath, fixture, registration, "delayed", "10"],
-    }),
-  )
-  const replacement = await Bun.file(registration).json()
-
-  expect((await Bun.file(registration + ".requests").text()).trim().split("\n")).toHaveLength(3)
-  expect(await existing.exited).toBe(0)
-  expect(replacement.pid).not.toBe(original.pid)
-  expect(endpoint.url).toBe(replacement.url)
-  expect(await health(endpoint.url)).toEqual({ healthy: true, version: "test", pid: replacement.pid })
-  process.kill(replacement.pid, "SIGTERM")
-}, 20_000)
-
 test("requests graceful stop of the exact service instance", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")

packages/core/src/config.ts

@@ -5,16 +5,8 @@ import path from "path"
 import { isDeepStrictEqual } from "node:util"
 import { type ParseError, parse } from "jsonc-parser"
 import { Context, Effect, Layer, Option, PubSub, Ref, Schema, Semaphore, Stream } from "effect"
-import {
-  AgentsDirectory,
-  ClaudeDirectory,
-  Directory,
-  Document,
-  File,
-  Info,
-  type Entry,
-  Event,
-} from "@opencode-ai/schema/config"
+import { Permission } from "@opencode-ai/schema/permission"
+import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { Integration } from "@opencode-ai/schema/integration"
 import { Credential } from "./credential"
 import { Bus } from "./bus"
@@ -23,11 +15,141 @@ import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
 import { Location } from "./location"
 import { AbsolutePath } from "./schema"
+import { ConfigAgent } from "./config/agent"
+import { ConfigMedia } from "./config/media"
+import { ConfigCompaction } from "./config/compaction"
+import { ConfigCommand } from "./config/command"
+import { ConfigExperimental } from "./config/experimental"
+import { ConfigFormatter } from "./config/formatter"
+import { ConfigLSP } from "./config/lsp"
+import { ConfigMCP } from "./config/mcp"
+import { ConfigModel } from "./config/model"
+import { ConfigPlugin } from "./config/plugin"
+import { ConfigProvider } from "./config/provider"
+import { ConfigReference } from "./config/reference"
+import { ConfigWebSearch } from "./config/websearch"
+import { ConfigToolOutput } from "./config/tool-output"
 import { ConfigVariable } from "./config/variable"
+import { ConfigWatcher } from "./config/watcher"
+import { ConfigWarming } from "./config/warming"
 import { ConfigV1 } from "./v1/config/config"
 import { ConfigMigrateV1 } from "./v1/config/migrate"
 import { WellKnown } from "./wellknown"
 
+export class Info extends Schema.Class<Info>("Config.Info")({
+  $schema: Schema.optional(Schema.String).annotate({
+    description: "JSON schema reference for configuration validation",
+  }),
+  shell: Schema.String.pipe(Schema.optional).annotate({
+    description: "Default shell to use for terminal and shell tool execution",
+  }),
+  model: ConfigModel.Selection.pipe(Schema.optional).annotate({
+    description: "Default model to use when no session or agent model is selected",
+  }),
+  default_agent: Schema.String.pipe(Schema.optional).annotate({
+    description: "Default primary agent to use when no session agent is selected",
+  }),
+  autoupdate: Schema.Union([Schema.Boolean, Schema.Literal("notify")])
+    .pipe(Schema.optional)
+    .annotate({
+      description: "Automatically update or notify when a new version is available",
+    }),
+  share: Schema.Literals(["manual", "auto", "disabled"]).pipe(Schema.optional).annotate({
+    description: "Control whether sessions may be shared manually, automatically, or not at all",
+  }),
+  enterprise: Schema.Struct({
+    url: Schema.String.pipe(Schema.optional),
+  })
+    .pipe(Schema.optional)
+    .annotate({
+      description: "Enterprise sharing service configuration",
+    }),
+  username: Schema.String.pipe(Schema.optional).annotate({
+    description: "Username displayed in conversations and used for telemetry identity",
+  }),
+  permissions: Permission.Ruleset.pipe(Schema.optional).annotate({
+    description: "Ordered tool permission rules applied to agent tool use",
+  }),
+  agents: Schema.Record(Schema.String, ConfigAgent.Info).pipe(Schema.optional).annotate({
+    description: "Named built-in agent overrides and custom agent definitions",
+  }),
+  snapshots: Schema.Boolean.pipe(Schema.optional).annotate({
+    description: "Enable snapshots used for undo and revert behavior",
+  }),
+  watcher: ConfigWatcher.Info.pipe(Schema.optional).annotate({
+    description: "Filesystem watcher configuration",
+  }),
+  formatter: ConfigFormatter.Info.pipe(Schema.optional).annotate({
+    description: "Enable built-in formatters or configure formatter overrides",
+  }),
+  lsp: ConfigLSP.Info.pipe(Schema.optional).annotate({
+    description: "Enable built-in language servers or configure server overrides",
+  }),
+  media: ConfigMedia.Info.pipe(Schema.optional).annotate({
+    description: "Media processing configuration",
+  }),
+  tool_output: ConfigToolOutput.Info.pipe(Schema.optional).annotate({
+    description: "Tool output truncation thresholds",
+  }),
+  mcp: ConfigMCP.Info.pipe(Schema.optional).annotate({
+    description: "MCP server configuration",
+  }),
+  compaction: ConfigCompaction.Info.pipe(Schema.optional).annotate({
+    description: "Conversation compaction behavior",
+  }),
+  skills: Schema.String.pipe(Schema.Array, Schema.optional).annotate({
+    description: "Additional paths or URLs to discover skills from",
+  }),
+  commands: Schema.Record(Schema.String, ConfigCommand.Info).pipe(Schema.optional).annotate({
+    description: "Named slash command definitions",
+  }),
+  instructions: Schema.String.pipe(Schema.Array, Schema.optional).annotate({
+    description: "Additional paths or URLs supplying ambient instructions",
+  }),
+  references: ConfigReference.Info.pipe(Schema.optional).annotate({
+    description: "Named local directories or Git repositories available as external context",
+  }),
+  websearch: ConfigWebSearch.Info.pipe(Schema.optional).annotate({
+    description: "Web search provider selection",
+  }),
+  plugins: ConfigPlugin.Plugins.pipe(Schema.optional).annotate({
+    description: "Ordered plugin enablement directives and external package declarations",
+  }),
+  warming: ConfigWarming.Warming.pipe(Schema.optional).annotate({
+    description: "Keep recently active sessions warm with transient model requests (default: false)",
+  }),
+  providers: Schema.Record(Schema.String, ConfigProvider.Info).pipe(Schema.optional),
+  experimental: ConfigExperimental.Info.pipe(Schema.optional),
+}) {}
+
+export class Document extends Schema.Class<Document>("Config.Document")({
+  type: Schema.Literal("document"),
+  path: Schema.String.pipe(Schema.optional),
+  info: Info,
+}) {}
+
+export class Directory extends Schema.Class<Directory>("Config.Directory")({
+  type: Schema.Literal("directory"),
+  path: AbsolutePath,
+}) {}
+
+export class File extends Schema.Class<File>("Config.File")({
+  type: Schema.Literal("file"),
+  path: AbsolutePath,
+}) {}
+
+export class AgentsDirectory extends Schema.Class<AgentsDirectory>("Config.AgentsDirectory")({
+  type: Schema.Literal("agents"),
+  path: AbsolutePath,
+}) {}
+
+export class ClaudeDirectory extends Schema.Class<ClaudeDirectory>("Config.ClaudeDirectory")({
+  type: Schema.Literal("claude"),
+  path: AbsolutePath,
+}) {}
+
+export type Entry = Document | Directory | File | AgentsDirectory | ClaudeDirectory
+
 export function latest<K extends keyof Info>(entries: readonly Entry[], key: K): Info[K] | undefined {
   return entries
     .filter((entry): entry is Document => entry.type === "document")
@@ -174,17 +296,21 @@ export const layer = (options?: Options) => Layer.effect(
 
       // We load certain files from a few other folders in the ecosystem
       const claude = [
-        ...new Set([
-          ...((yield* fs.isDir(globalClaudeDirectory)) ? [globalClaudeDirectory] : []),
-          ...discovered.filter((item) => path.basename(item) === ".claude"),
-        ]),
-      ].map((directory) => new ClaudeDirectory({ type: "claude", path: AbsolutePath.make(directory) }))
+        ...((yield* fs.isDir(globalClaudeDirectory))
+          ? [new ClaudeDirectory({ type: "claude", path: globalClaudeDirectory })]
+          : []),
+        ...discovered
+          .filter((item) => path.basename(item) === ".claude")
+          .map((directory) => new ClaudeDirectory({ type: "claude", path: AbsolutePath.make(directory) })),
+      ]
       const agents = [
-        ...new Set([
-          ...((yield* fs.isDir(globalAgentsDirectory)) ? [globalAgentsDirectory] : []),
-          ...discovered.filter((item) => path.basename(item) === ".agents"),
-        ]),
-      ].map((directory) => new AgentsDirectory({ type: "agents", path: AbsolutePath.make(directory) }))
+        ...((yield* fs.isDir(globalAgentsDirectory))
+          ? [new AgentsDirectory({ type: "agents", path: globalAgentsDirectory })]
+          : []),
+        ...discovered
+          .filter((item) => path.basename(item) === ".agents")
+          .map((directory) => new AgentsDirectory({ type: "agents", path: AbsolutePath.make(directory) })),
+      ]
 
       const directories = [
         globalDirectory,
@@ -282,7 +408,7 @@ export const layer = (options?: Options) => Layer.effect(
           if (isDeepStrictEqual(configs, next)) return
           configs = next
           yield* reconcile(next)
-          yield* bus.publish(Event.Updated, {})
+          yield* bus.publish(ConfigSchema.Event.Updated, {})
         }),
       ),
     )

packages/core/src/config/agent.ts

@@ -1,10 +1,10 @@
-export * as ConfigAgent from "./agent.js"
+export * as ConfigAgent from "./agent"
 
 import { Schema } from "effect"
-import { Permission } from "../permission.js"
-import { PositiveInt } from "../schema.js"
-import { ConfigModel } from "./model.js"
-import { ConfigProvider } from "./provider.js"
+import { Permission } from "@opencode-ai/schema/permission"
+import { ConfigProvider } from "./provider"
+import { ConfigModel } from "./model"
+import { PositiveInt } from "../schema"
 
 export const Color = Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/))
 

packages/core/src/config/command.ts

@@ -1,7 +1,7 @@
-export * as ConfigCommand from "./command.js"
+export * as ConfigCommand from "./command"
 
 import { Schema } from "effect"
-import { ConfigModel } from "./model.js"
+import { ConfigModel } from "./model"
 
 export class Info extends Schema.Class<Info>("Config.Command")({
   template: Schema.String,

packages/core/src/config/compaction.ts

@@ -1,7 +1,7 @@
-export * as ConfigCompaction from "./compaction.js"
+export * as ConfigCompaction from "./compaction"
 
 import { Schema } from "effect"
-import { NonNegativeInt } from "../schema.js"
+import { NonNegativeInt } from "../schema"
 
 export class Keep extends Schema.Class<Keep>("Config.Compaction.Keep")({
   tokens: NonNegativeInt.pipe(Schema.optional),

packages/core/src/config/experimental.ts

@@ -1,8 +1,8 @@
-export * as ConfigExperimental from "./experimental.js"
+export * as ConfigExperimental from "./experimental"
 
 import { Schema } from "effect"
-import { NonNegativeInt } from "../schema.js"
-import { ConfigPolicy } from "./policy.js"
+import { NonNegativeInt } from "../schema"
+import { ConfigPolicy } from "./policy"
 
 export class Info extends Schema.Class<Info>("ConfigExperimental.Info")({
   subagent_depth: NonNegativeInt.pipe(Schema.optional).annotate({

packages/core/src/config/formatter.ts

@@ -1,4 +1,4 @@
-export * as ConfigFormatter from "./formatter.js"
+export * as ConfigFormatter from "./formatter"
 
 import { Schema } from "effect"
 

packages/core/src/config/lsp.ts

@@ -1,4 +1,4 @@
-export * as ConfigLSP from "./lsp.js"
+export * as ConfigLSP from "./lsp"
 
 import { Schema } from "effect"
 

packages/core/src/config/mcp.ts

@@ -1,8 +1,10 @@
-export * as ConfigMCP from "./mcp.js"
+export * as ConfigMCP from "./mcp"
 
 import { Schema } from "effect"
-import { Mcp } from "../mcp.js"
+import { Mcp } from "@opencode-ai/schema/mcp"
 
+// The MCP server config is a public wire contract (used by the mcp.add route), so it lives in
+// @opencode-ai/schema and is re-exported here.
 export const Timeout = Mcp.TimeoutConfig
 export type Timeout = Mcp.TimeoutConfig
 export const Local = Mcp.LocalConfig

packages/core/src/config/media.ts

@@ -1,7 +1,7 @@
-export * as ConfigMedia from "./media.js"
+export * as ConfigMedia from "./media"
 
 import { Schema } from "effect"
-import { PositiveInt } from "../schema.js"
+import { PositiveInt } from "../schema"
 
 export class Image extends Schema.Class<Image>("Config.Media.Image")({
   auto_resize: Schema.Boolean.pipe(Schema.optional),

packages/core/src/config/model.ts

@@ -1,8 +1,8 @@
-export * as ConfigModel from "./model.js"
+export * as ConfigModel from "./model"
 
 import { Schema, SchemaGetter } from "effect"
-import { Model } from "../model.js"
-import { Provider } from "../provider.js"
+import { Model } from "@opencode-ai/schema/model"
+import { Provider } from "@opencode-ai/schema/provider"
 
 const ProviderID = Provider.ID.check(Schema.isPattern(/^[^/#]+$/))
 const ModelID = Model.ID.check(Schema.isPattern(/^[^#]+$/))

packages/core/src/config/plugin.ts

@@ -1,4 +1,4 @@
-export * as ConfigPlugin from "./plugin.js"
+export * as ConfigPlugin from "./plugin"
 
 import { Schema } from "effect"
 

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

@@ -1,12 +1,11 @@
 export * as ConfigAgentPlugin from "./agent"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Document, Info, type Entry } from "@opencode-ai/schema/config"
-import { ConfigAgent } from "@opencode-ai/schema/config/agent"
 import path from "path"
 import { Effect, Option, Schema, Stream } from "effect"
 import { Agent } from "../../agent"
 import { Config } from "../../config"
+import { ConfigAgent } from "../agent"
 import { ConfigMarkdown } from "../markdown"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { ConfigAgentV1 } from "../../v1/config/agent"
@@ -25,7 +24,7 @@ const legacySources = [
 const sourceDirectories = ["agent", "agents", "mode", "modes"] as const
 const decodeAgent = Schema.decodeUnknownOption(ConfigAgent.Info)
 const decodeLegacyAgent = Schema.decodeUnknownOption(ConfigAgentV1.Info)
-const decodeConfig = Schema.decodeUnknownOption(Info)
+const decodeConfig = Schema.decodeUnknownOption(Config.Info)
 type PathAction =
   | LocationMutation.ExternalDirectoryAuthorization["action"]
   | typeof ReadTool.name
@@ -64,13 +63,13 @@ export const Plugin = define({
             ),
           ).pipe(
             Effect.map((documents) =>
-              documents.filter((document): document is Document => document !== undefined),
+              documents.filter((document): document is Config.Document => document !== undefined),
             ),
           )
         })
       }).pipe(Effect.map((documents) => documents.flat()))
     })
-    const loaded = { documents: [] as Document[] }
+    const loaded = { documents: [] as Config.Document[] }
     const reload = load().pipe(
       Effect.tap((documents) => Effect.sync(() => (loaded.documents = documents))),
       Effect.andThen(ctx.agent.reload()),
@@ -140,7 +139,7 @@ export const Plugin = define({
 
 // Matches anything at or under <root>/{agent,agents,mode,modes}. No file-suffix
 // check: directory-level events such as renames carry no per-file paths.
-function isAgentSource(entries: Entry[], file: string) {
+function isAgentSource(entries: Config.Entry[], file: string) {
   return entries.some(
     (entry) =>
       entry.type === "directory" &&
@@ -209,5 +208,5 @@ function decode(file: { directory: string; filepath: string; primary: boolean },
     }),
   )
   if (!info) return
-  return new Document({ type: "document", path: file.filepath, info })
+  return new Config.Document({ type: "document", path: file.filepath, info })
 }

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

@@ -1,13 +1,12 @@
 export * as ConfigCommandPlugin from "./command"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Info, type Entry } from "@opencode-ai/schema/config"
-import { ConfigCommand } from "@opencode-ai/schema/config/command"
 import path from "path"
 import { Effect, Option, Schema, Stream } from "effect"
 import { Command } from "../../command"
 import { Config } from "../../config"
 import { FSUtil } from "@opencode-ai/util/fs-util"
+import { ConfigCommand } from "../command"
 import { ConfigMarkdown } from "../markdown"
 
 const decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info)
@@ -28,7 +27,7 @@ export const Plugin = define({
         )
       }).pipe(Effect.map((documents) => documents.flat()))
     })
-    const loaded = { documents: [] as { commands: Info["commands"] }[] }
+    const loaded = { documents: [] as { commands: Config.Info["commands"] }[] }
     const reload = load().pipe(
       Effect.tap((documents) => Effect.sync(() => (loaded.documents = documents))),
       Effect.andThen(ctx.command.reload()),
@@ -76,7 +75,7 @@ const sourceDirectories = ["command", "commands"] as const
 
 // Matches anything at or under <root>/{command,commands}. No file-suffix check:
 // directory-level events such as renames carry no per-file paths.
-function isCommandSource(entries: Entry[], file: string) {
+function isCommandSource(entries: Config.Entry[], file: string) {
   return entries.some(
     (entry) =>
       entry.type === "directory" &&

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

@@ -1,7 +1,6 @@
 export * as ConfigPolicyPlugin from "./policy"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Document } from "@opencode-ai/schema/config"
 import { Effect, Stream } from "effect"
 import { Config } from "../../config"
 import { Wildcard } from "../../util/wildcard"
@@ -14,7 +13,7 @@ export const Plugin = define({
     yield* ctx.catalog.transform((catalog) => {
       // User-global policy takes priority over policy authored by a repository.
       const policies = loaded.entries
-        .filter((entry): entry is Document => entry.type === "document")
+        .filter((entry): entry is Config.Document => entry.type === "document")
         .toReversed()
         .flatMap((entry) => entry.info.experimental?.policies ?? [])
       for (const record of catalog.provider.list()) {

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

@@ -1,7 +1,6 @@
 export * as ConfigProviderPlugin from "./provider"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Document, type Entry } from "@opencode-ai/schema/config"
 import { Money } from "@opencode-ai/schema/money"
 import { Effect, Stream } from "effect"
 import { Config } from "../../config"
@@ -108,8 +107,8 @@ export const Plugin = define({
   }),
 })
 
-function configuredProviders(entries: readonly Entry[]) {
+function configuredProviders(entries: readonly Config.Entry[]) {
   return entries
-    .filter((entry): entry is Document => entry.type === "document")
+    .filter((entry): entry is Config.Document => entry.type === "document")
     .flatMap((file) => Object.entries(file.info.providers ?? {}))
 }

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

@@ -1,11 +1,10 @@
 export * as ConfigReferencePlugin from "./reference"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Document } from "@opencode-ai/schema/config"
-import { ConfigReference } from "@opencode-ai/schema/config/reference"
 import path from "path"
 import { Effect, Stream } from "effect"
 import { Config } from "../../config"
+import { ConfigReference } from "../reference"
 import { Reference } from "../../reference"
 import { AbsolutePath } from "../../schema"
 import { Global } from "@opencode-ai/util/global"
@@ -20,7 +19,7 @@ export const Plugin = define({
     const loaded = { entries: yield* config.entries() }
     yield* ctx.reference.transform((draft) => {
       const entries = new Map<string, Reference.Source>()
-      for (const doc of loaded.entries.filter((entry): entry is Document => entry.type === "document")) {
+      for (const doc of loaded.entries.filter((entry): entry is Config.Document => entry.type === "document")) {
         const directory = doc.path ? path.dirname(doc.path) : location.directory
         for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
           if (!validAlias(name)) continue

packages/core/src/config/policy.ts

@@ -1,4 +1,4 @@
-export * as ConfigPolicy from "./policy.js"
+export * as ConfigPolicy from "./policy"
 
 import { Schema } from "effect"
 

packages/core/src/config/provider.ts

@@ -1,8 +1,8 @@
-export * as ConfigProvider from "./provider.js"
+export * as ConfigProvider from "./provider"
 
 import { Schema } from "effect"
-import { Money } from "../money.js"
-import { Capabilities, Compatibility, Family, ID, VariantID } from "../model.js"
+import { Money } from "@opencode-ai/schema/money"
+import { Capabilities, Compatibility, Family, ID, VariantID } from "../model"
 
 const JsonRecord = Schema.Record(Schema.String, Schema.Json)
 

packages/core/src/config/reference.ts

@@ -1,4 +1,4 @@
-export * as ConfigReference from "./reference.js"
+export * as ConfigReference from "./reference"
 
 import { Schema } from "effect"
 

packages/core/src/config/tool-output.ts

@@ -1,7 +1,7 @@
-export * as ConfigToolOutput from "./tool-output.js"
+export * as ConfigToolOutput from "./tool-output"
 
 import { Schema } from "effect"
-import { PositiveInt } from "../schema.js"
+import { PositiveInt } from "../schema"
 
 export class Info extends Schema.Class<Info>("Config.ToolOutput")({
   max_lines: PositiveInt.pipe(Schema.optional),

packages/core/src/config/warming.ts

@@ -1,4 +1,4 @@
-export * as ConfigWarming from "./warming.js"
+export * as ConfigWarming from "./warming"
 
 import { Schema } from "effect"
 

packages/core/src/config/watcher.ts

@@ -1,4 +1,4 @@
-export * as ConfigWatcher from "./watcher.js"
+export * as ConfigWatcher from "./watcher"
 
 import { Schema } from "effect"
 

packages/core/src/config/websearch.ts

@@ -1,7 +1,7 @@
-export * as ConfigWebSearch from "./websearch.js"
+export * as ConfigWebSearch from "./websearch"
 
+import { WebSearch } from "@opencode-ai/schema/websearch"
 import { Schema } from "effect"
-import { WebSearch } from "../websearch.js"
 
 export class Info extends Schema.Class<Info>("ConfigWebSearch.Info")({
   provider: WebSearch.ID,

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

@@ -3,7 +3,6 @@ export * as LocationWatcher from "./location-watcher"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Context, Effect, Layer, Stream } from "effect"
 import { FileSystem } from "@opencode-ai/schema/filesystem"
-import { Document } from "@opencode-ai/schema/config"
 import path from "path"
 import { Config } from "../config"
 import { Bus } from "../bus"
@@ -42,7 +41,7 @@ const layer = Layer.effect(
 
     yield* Effect.gen(function* () {
       const config = (yield* configService.entries())
-        .filter((entry): entry is Document => entry.type === "document")
+        .filter((entry): entry is Config.Document => entry.type === "document")
         .flatMap((item) => item.info.watcher?.ignore ?? [])
       const home = Protected.isHome(location.directory)
 

packages/core/src/form.ts

@@ -132,7 +132,6 @@ export const layer = Layer.effect(
             id,
             sessionID: input.sessionID,
             title: input.title,
-            ...(input.coalesce === undefined ? {} : { coalesce: input.coalesce }),
             ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
             fields: input.fields,
           }

packages/core/src/mcp/client.ts

@@ -29,7 +29,7 @@ import {
   ToolSchema,
 } from "@modelcontextprotocol/sdk/types.js"
 import { Cause, Effect, Exit, Schema } from "effect"
-import { ConfigMCP } from "@opencode-ai/schema/config/mcp"
+import { ConfigMCP } from "../config/mcp"
 
 const DEFAULT_STARTUP_TIMEOUT = 30_000
 const DEFAULT_CATALOG_TIMEOUT = 30_000

packages/core/src/mcp/index.ts

@@ -3,12 +3,11 @@ export * as MCP from "./index"
 import { Mcp } from "@opencode-ai/schema/mcp"
 import { McpEvent } from "@opencode-ai/schema/mcp-event"
 import { Command } from "@opencode-ai/schema/command"
-import { Document } from "@opencode-ai/schema/config"
-import { ConfigMCP } from "@opencode-ai/schema/config/mcp"
 import { createHash } from "node:crypto"
 import { Cause, Context, Deferred, Effect, Exit, FiberSet, Layer, Schema, Scope, Stream } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Config } from "../config"
+import { ConfigMCP } from "../config/mcp"
 import { Credential } from "../credential"
 import { Bus } from "../bus"
 import { Form } from "../form"
@@ -179,7 +178,7 @@ export const layer = (options?: Options) => Layer.effect(
     const fork = yield* FiberSet.makeRuntime<never, void, never>()
     yield* Effect.addFinalizer((exit) => Scope.close(root, exit))
 
-    const documents = (yield* config.entries()).filter((entry): entry is Document => entry.type === "document")
+    const documents = (yield* config.entries()).filter((entry): entry is Config.Document => entry.type === "document")
     // Global MCP timeout defaults, later config files overriding earlier ones.
     const timeout = Object.assign(
       {},

packages/core/src/mcp/oauth.ts

@@ -5,7 +5,7 @@ import type { OAuthClientInformationMixed, OAuthTokens } from "@modelcontextprot
 import { createServer } from "node:http"
 import { Deferred, Effect } from "effect"
 import { Credential } from "@opencode-ai/schema/credential"
-import { ConfigMCP } from "@opencode-ai/schema/config/mcp"
+import { ConfigMCP } from "../config/mcp"
 import { OauthCallbackPage } from "../oauth/page"
 import type { Integration } from "../integration"
 

packages/core/src/plugin/provider/github-copilot.ts

@@ -1,5 +1,4 @@
 import type { IntegrationOAuthMethodRegistration } from "@opencode-ai/plugin/effect/integration"
-import { shouldUseResponsesApi } from "@opencode-ai/ai/providers/github-copilot"
 import { Effect, Option, Schema, Semaphore, Stream } from "effect"
 import { Catalog } from "../../catalog"
 import { Credential } from "../../credential"
@@ -141,6 +140,14 @@ const oauth = (app: App.Info) => ({
     }),
 }) satisfies IntegrationOAuthMethodRegistration
 
+function shouldUseResponses(modelID: string) {
+  // Copilot supports Responses for GPT-5 class models, except mini variants
+  // which still need the chat-completions endpoint.
+  const match = /^gpt-(\d+)/.exec(modelID)
+  if (!match) return false
+  return Number(match[1]) >= 5 && !modelID.startsWith("gpt-5-mini")
+}
+
 export const GithubCopilotPlugin = define({
   id: "opencode.provider.github-copilot",
   effect: Effect.fn(function* (ctx) {
@@ -262,7 +269,7 @@ export const GithubCopilotPlugin = define({
           return
         }
         const id = evt.model.modelID ?? evt.model.id
-        evt.language = shouldUseResponsesApi(id) ? evt.sdk.responses(id) : evt.sdk.chat(id)
+        evt.language = shouldUseResponses(id) ? evt.sdk.responses(id) : evt.sdk.chat(id)
       }),
     )
   }),

packages/core/src/plugin/supervisor.ts

@@ -1,8 +1,7 @@
 export * as PluginSupervisor from "./supervisor"
 
 import type { Plugin as PluginDefinition } from "@opencode-ai/plugin/effect/plugin"
-import { Directory, Document, Event, type Entry } from "@opencode-ai/schema/config"
-import { ConfigPlugin } from "@opencode-ai/schema/config/plugin"
+import { Event } from "@opencode-ai/schema/config"
 import { Context, Deferred, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
 import path from "path"
 import { fileURLToPath, pathToFileURL } from "url"
@@ -10,6 +9,7 @@ import { Agent } from "../agent"
 import { Catalog } from "../catalog"
 import { Command } from "../command"
 import { Config } from "../config"
+import { ConfigPlugin } from "../config/plugin"
 import { Credential } from "../credential"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform"
@@ -83,15 +83,15 @@ function parse(input: ConfigPlugin.Plugin): Operation {
   return { type: "remove", target: input.slice(1) }
 }
 
-const scan = Effect.fn("PluginSupervisor.scan")(function* (entries: readonly Entry[]) {
+const scan = Effect.fn("PluginSupervisor.scan")(function* (entries: readonly Config.Entry[]) {
   const fs = yield* FSUtil.Service
   const location = yield* Location.Service
   const discovered = yield* Effect.forEach(
-    entries.filter((entry): entry is Directory => entry.type === "directory"),
+    entries.filter((entry): entry is Config.Directory => entry.type === "directory"),
     (entry) => discoverDirectory(fs, entry.path),
   ).pipe(Effect.map((items) => items.flat()))
   const configured = entries
-    .filter((entry): entry is Document => entry.type === "document")
+    .filter((entry): entry is Config.Document => entry.type === "document")
     .flatMap((entry) =>
       (entry.info.plugins ?? []).map(parse).map((operation) => {
         if (operation.type === "remove") return operation
@@ -208,7 +208,7 @@ function discoverDirectory(fs: FSUtil.Interface, directory: string) {
 
 const sourceDirectories = ["plugin", "plugins"] as const
 
-function isPluginSource(entries: readonly Entry[], file: string) {
+function isPluginSource(entries: readonly Config.Entry[], file: string) {
   return entries.some(
     (entry) =>
       entry.type === "directory" &&
@@ -243,7 +243,7 @@ const layer = Layer.effect(
     const configuredChanges = yield* PubSub.unbounded<void>()
     const watched = new Set<string>()
     const watchConfiguredSources = Effect.fn("PluginSupervisor.watchConfiguredSources")(function* (
-      entries: readonly Entry[],
+      entries: readonly Config.Entry[],
       operations: readonly Operation[],
     ) {
       for (const operation of operations) {

packages/core/src/session/compaction.ts

@@ -2,7 +2,6 @@ export * as SessionCompaction from "./compaction"
 
 import { LLM, LLMClient, AIError, LLMEvent, Message, type LLMRequest, type LanguageModel } from "@opencode-ai/ai"
 import { SessionError } from "@opencode-ai/schema/session-error"
-import { Document, type Entry } from "@opencode-ai/schema/config"
 import { Context, Effect, Layer, Stream } from "effect"
 import { Config } from "../config"
 import { Bus } from "../bus"
@@ -149,9 +148,9 @@ const serialize = (message: SessionMessage.Info) => {
   return ""
 }
 
-const settings = (documents: readonly Entry[]) => {
+const settings = (documents: readonly Config.Entry[]) => {
   const configured = documents
-    .filter((entry): entry is Document => entry.type === "document")
+    .filter((entry): entry is Config.Document => entry.type === "document")
     .flatMap((entry) => (entry.info.compaction ? [entry.info.compaction] : []))
   return {
     auto: configured.findLast((value) => value.auto !== undefined)?.auto ?? true,

packages/core/src/session/transfer.ts

@@ -0,0 +1,323 @@
+export * as SessionTransfer from "./transfer"
+
+import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
+import { Tool } from "@opencode-ai/schema/tool"
+import { eq, isNotNull, isNull, ne, or } from "drizzle-orm"
+import { Context, DateTime, Effect, Layer, Schema } from "effect"
+import path from "path"
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
+import { App } from "../app"
+import { Bus } from "../bus"
+import { Database } from "../database/database"
+import { Location } from "../location"
+import { Project } from "../project"
+import { ProjectTable } from "../project/sql"
+import { AbsolutePath, RelativePath } from "../schema"
+import { Session } from "../session"
+import { Slug } from "../util/slug"
+import { SessionEvent } from "./event"
+import { SessionMessage } from "./message"
+import { SessionProjector } from "./projector"
+import { SessionMessageTable, SessionTable } from "./sql"
+
+export const Data = SessionTransfer.Data
+export type Data = SessionTransfer.Data
+
+export class ImportConflictError extends Schema.TaggedErrorClass<ImportConflictError>()(
+  "SessionTransfer.ImportConflictError",
+  { sessionID: Session.ID },
+) {}
+
+export interface Interface {
+  readonly export: (input: {
+    sessionID: Session.ID
+    sanitize?: boolean
+  }) => Effect.Effect<Data, Session.NotFoundError | Session.MessageDecodeError>
+  readonly import: (input: {
+    data: Data
+    location: Location.Ref
+  }) => Effect.Effect<Session.Info, ImportConflictError>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/SessionTransfer") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const app = yield* App.Metadata
+    const bus = yield* Bus.Service
+    const { db } = yield* Database.Service
+    const projects = yield* Project.Service
+    const sessions = yield* Session.Service
+    const encodeMessage = Schema.encodeSync(SessionMessage.Info)
+
+    const persistProject = (project: Project.Resolved) => {
+      const vcs = project.vcs?.type
+      return db
+        .insert(ProjectTable)
+        .values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] })
+        .onConflictDoUpdate({
+          target: ProjectTable.id,
+          set: { worktree: project.canonical, vcs: vcs ?? null },
+          setWhere: or(
+            ne(ProjectTable.worktree, project.canonical),
+            vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs),
+          ),
+        })
+        .run()
+        .pipe(Effect.orDie)
+    }
+
+    return Service.of({
+      export: Effect.fn("SessionTransfer.export")(function* (input) {
+        const data = {
+          info: yield* sessions.get(input.sessionID),
+          messages: yield* sessions.messages({ sessionID: input.sessionID, order: "asc" }),
+        }
+        return input.sanitize ? sanitize(data) : data
+      }),
+      import: Effect.fn("SessionTransfer.import")(function* (input) {
+        const sessionID = input.data.info.id
+        const recorded = yield* db
+          .select({ id: SessionTable.id })
+          .from(SessionTable)
+          .where(eq(SessionTable.id, sessionID))
+          .get()
+          .pipe(Effect.orDie)
+        if (recorded) return yield* new ImportConflictError({ sessionID })
+        const project = yield* projects.resolve(input.location.directory)
+        yield* persistProject(project)
+        const messages = input.data.messages.map((message, index) => {
+          const encoded = encodeMessage(message)
+          const { id: _, type, ...data } = encoded
+          return {
+            id: message.id,
+            session_id: sessionID,
+            type,
+            seq: index + 1,
+            time_created: DateTime.toEpochMillis(message.time.created),
+            data,
+          }
+        })
+        yield* bus
+          .publish(
+            SessionEvent.Created,
+            {
+              sessionID,
+              slug: Slug.create(),
+              version: app.version,
+              projectID: project.id,
+              location: input.location,
+              subpath: RelativePath.make(path.relative(project.directory, input.location.directory).replaceAll("\\", "/")),
+              title: input.data.info.title,
+              agent: input.data.info.agent,
+              model: input.data.info.model,
+            },
+            {
+              location: input.location,
+              commit: (seq) =>
+                Effect.gen(function* () {
+                  if (messages.length > 0) {
+                    yield* db.insert(SessionMessageTable).values(messages).run().pipe(Effect.orDie)
+                    yield* Bus.reserveSequence(db, sessionID, seq + messages.length)
+                  }
+                  yield* db
+                    .update(SessionTable)
+                    .set({
+                      cost: input.data.info.cost,
+                      tokens_input: input.data.info.tokens.input,
+                      tokens_output: input.data.info.tokens.output,
+                      tokens_reasoning: input.data.info.tokens.reasoning,
+                      tokens_cache_read: input.data.info.tokens.cache.read,
+                      tokens_cache_write: input.data.info.tokens.cache.write,
+                      time_created: DateTime.toEpochMillis(input.data.info.time.created),
+                      time_updated: DateTime.toEpochMillis(input.data.info.time.updated),
+                      time_archived: input.data.info.time.archived
+                        ? DateTime.toEpochMillis(input.data.info.time.archived)
+                        : null,
+                    })
+                    .where(eq(SessionTable.id, sessionID))
+                    .run()
+                    .pipe(Effect.orDie)
+                }),
+            },
+          )
+          .pipe(
+            Effect.catchDefect((defect) =>
+              defect instanceof SessionProjector.SessionAlreadyProjected
+                ? Effect.fail(new ImportConflictError({ sessionID }))
+                : Effect.die(defect),
+            ),
+          )
+        return yield* sessions.get(sessionID).pipe(Effect.orDie)
+      }),
+    })
+  }),
+)
+
+export const node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [App.node, Bus.node, Database.node, Project.node, Session.node],
+})
+
+function redact(kind: string, id: string, value: string) {
+  return value.trim() ? `[redacted:${kind}:${id}]` : value
+}
+
+function metadata(kind: string, id: string, value: Readonly<Record<string, unknown>> | undefined) {
+  if (!value) return value
+  return Object.keys(value).length > 0 ? { redacted: `${kind}:${id}` } : value
+}
+
+function sanitize(data: Data): Data {
+  return {
+    info: {
+      ...data.info,
+      title: data.info.title === undefined ? undefined : redact("session-title", data.info.id, data.info.title),
+      location: {
+        ...data.info.location,
+        directory: AbsolutePath.make(`/${redact("session-directory", data.info.id, data.info.location.directory)}`),
+      },
+      revert: data.info.revert
+        ? {
+            ...data.info.revert,
+            files: data.info.revert.files?.map((file, index) => ({
+              ...file,
+              file: redact("revert-file", String(index), file.file),
+              patch: redact("revert-patch", String(index), file.patch),
+            })),
+          }
+        : undefined,
+    },
+    messages: data.messages.map(sanitizeMessage),
+  }
+}
+
+function sanitizeMessage(message: SessionMessage.Info): SessionMessage.Info {
+  const meta = metadata("message-metadata", message.id, message.metadata)
+  if (message.type === "user")
+    return {
+      ...message,
+      metadata: meta,
+      text: redact("text", message.id, message.text),
+      files: message.files?.map((file, index) => ({
+        ...file,
+        data: "",
+        source: { type: "inline" },
+        name: file.name === undefined ? undefined : redact("file-name", String(index), file.name),
+        description:
+          file.description === undefined ? undefined : redact("file-description", String(index), file.description),
+        mention: file.mention
+          ? { ...file.mention, text: redact("file-mention", String(index), file.mention.text) }
+          : undefined,
+      })),
+      agents: message.agents?.map((agent, index) => ({
+        ...agent,
+        name: redact("agent-name", String(index), agent.name),
+        mention: agent.mention
+          ? { ...agent.mention, text: redact("agent-mention", String(index), agent.mention.text) }
+          : undefined,
+      })),
+    }
+  if (message.type === "synthetic")
+    return {
+      ...message,
+      metadata: meta,
+      text: redact("synthetic", message.id, message.text),
+      description:
+        message.description === undefined
+          ? undefined
+          : redact("synthetic-description", message.id, message.description),
+    }
+  if (message.type === "system")
+    return { ...message, metadata: meta, text: redact("system", message.id, message.text) }
+  if (message.type === "skill") return { ...message, metadata: meta, text: redact("skill", message.id, message.text) }
+  if (message.type === "shell")
+    return {
+      ...message,
+      metadata: meta,
+      command: redact("shell-command", message.id, message.command),
+      output: message.output
+        ? { ...message.output, output: redact("shell-output", message.id, message.output.output) }
+        : undefined,
+    }
+  if (message.type === "assistant")
+    return {
+      ...message,
+      metadata: meta,
+      content: message.content.map((content) => {
+        if (content.type === "text")
+          return {
+            ...content,
+            text: redact("text", message.id, content.text),
+            state: content.state ? { redacted: `text-state:${message.id}` } : undefined,
+          }
+        if (content.type === "reasoning")
+          return {
+            ...content,
+            text: redact("reasoning", message.id, content.text),
+            state: content.state ? { redacted: `reasoning-state:${message.id}` } : undefined,
+          }
+        return {
+          ...content,
+          providerState: content.providerState ? { redacted: `tool-provider-state:${message.id}` } : undefined,
+          providerResultState: content.providerResultState
+            ? { redacted: `tool-provider-result-state:${message.id}` }
+            : undefined,
+          state: sanitizeToolState(message.id, content.state),
+        }
+      }),
+    }
+  if (message.type === "compaction") {
+    if (message.status === "failed")
+      return {
+        ...message,
+        metadata: meta,
+      }
+    return {
+      ...message,
+      metadata: meta,
+      summary: redact("compaction-summary", message.id, message.summary),
+      recent: redact("compaction-recent", message.id, message.recent),
+    }
+  }
+  return { ...message, metadata: meta }
+}
+
+function sanitizeToolState(id: string, state: SessionMessage.ToolState): SessionMessage.ToolState {
+  if (state.status === "streaming") return { ...state, input: redact("tool-input", id, state.input) }
+  if (state.status === "running")
+    return { ...state, input: { redacted: `tool-input:${id}` }, metadata: { redacted: `tool-metadata:${id}` } }
+  const meta = state.metadata === undefined ? undefined : { redacted: `tool-metadata:${id}` }
+  if (state.status === "completed")
+    return {
+      ...state,
+      input: { redacted: `tool-input:${id}` },
+      content: [
+        sanitizeToolContent(id, state.content[0]),
+        ...state.content.slice(1).map((item) => sanitizeToolContent(id, item)),
+      ],
+      metadata: meta,
+    }
+  return {
+    ...state,
+    input: { redacted: `tool-input:${id}` },
+    content: state.content
+      ? [
+          sanitizeToolContent(id, state.content[0]),
+          ...state.content.slice(1).map((item) => sanitizeToolContent(id, item)),
+        ]
+      : undefined,
+    metadata: meta,
+  }
+}
+
+function sanitizeToolContent(id: string, content: Tool.Content): Tool.Content {
+  if (content.type === "text") return { ...content, text: redact("tool-output", id, content.text) }
+  return {
+    ...content,
+    uri: redact("tool-file-uri", id, content.uri),
+    name: content.name === undefined ? undefined : redact("tool-file-name", id, content.name),
+  }
+}

packages/core/src/tool/plugin/websearch.ts

@@ -59,7 +59,6 @@ export const Plugin = {
                     const response = yield* forms.ask({
                       sessionID: context.sessionID,
                       title: "Web Search",
-                      coalesce: `${context.messageID}:websearch-consent`,
                       metadata: { kind: "websearch.provider" },
                       fields: [
                         {
@@ -92,7 +91,6 @@ export const Plugin = {
                         ? yield* forms.ask({
                             sessionID: context.sessionID,
                             title: "Choose a web search provider",
-                            coalesce: `${context.messageID}:websearch-provider`,
                             metadata: { kind: "websearch.provider" },
                             fields: [
                               {

packages/core/src/v1/config/config.ts

@@ -1,8 +1,8 @@
 export * as ConfigV1 from "./config"
 
 import { Schema } from "effect"
-import { ConfigReference } from "@opencode-ai/schema/config/reference"
 import { NonNegativeInt, PositiveInt, type DeepMutable } from "../../schema"
+import { ConfigReference } from "../../config/reference"
 import { ConfigAgentV1 } from "./agent"
 import { ConfigAttachmentV1 } from "./attachment"
 import { ConfigCommandV1 } from "./command"

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

@@ -5,7 +5,6 @@ import { Effect, Fiber, Schema, Stream } from "effect"
 import { Agent } from "@opencode-ai/core/agent"
 import { Bus } from "@opencode-ai/core/bus"
 import { Config } from "@opencode-ai/core/config"
-import { Directory, Document, Info } from "@opencode-ai/schema/config"
 import { ConfigAgentPlugin } from "@opencode-ai/core/config/plugin/agent"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
@@ -20,7 +19,7 @@ import { testEffect } from "../lib/effect"
 import { agentHost, host } from "../plugin/host"
 
 const it = testEffect(AppNodeBuilder.build(LayerNode.group([Agent.node, Bus.node, FSUtil.node, Global.node])))
-const decode = Schema.decodeUnknownSync(Info)
+const decode = Schema.decodeUnknownSync(Config.Info)
 const defaultPermissions = (global: Global.Interface): Permission.Ruleset => [
   ...Agent.Info.default(Agent.ID.make("test")).permissions,
   { action: "external_directory", resource: path.join(global.data, "shell", "*", "*"), effect: "allow" },
@@ -72,7 +71,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
       )
 
       const entries = [
-        new Document({
+        new Config.Document({
           type: "document",
           info: decode({
             permissions: [{ action: "bash", resource: "*", effect: "ask" }],
@@ -93,7 +92,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
             },
           }),
         }),
-        new Document({
+        new Config.Document({
           type: "document",
           info: decode({
             permissions: [{ action: "read", resource: "*", effect: "allow" }],
@@ -154,7 +153,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
     Effect.gen(function* () {
       const agents = yield* Agent.Service
       const entries = [
-        new Document({
+        new Config.Document({
           type: "document",
           info: decode({
             agents: {
@@ -174,7 +173,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
             },
           }),
         }),
-        new Document({
+        new Config.Document({
           type: "document",
           info: decode({
             agents: {
@@ -219,7 +218,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
       yield* agents.transform((editor) => editor.update(build, () => {}))
 
       const entries = [
-        new Document({
+        new Config.Document({
           type: "document",
           info: decode({ agents: { build: { disabled: true } } }),
         }),
@@ -277,7 +276,7 @@ Use native v2 fields.`,
           const agents = yield* Agent.Service
           const global = yield* Global.Service
           const entries = [
-            new Document({
+            new Config.Document({
               type: "document",
               info: decode({ agents: { reviewer: { description: "JSON description" } } }),
             }),
@@ -426,7 +425,7 @@ Use native v2 fields.`,
 })
 
 function directoryEntry(directory: string) {
-  return new Directory({ type: "directory", path: AbsolutePath.make(directory) })
+  return new Config.Directory({ type: "directory", path: AbsolutePath.make(directory) })
 }
 
 function sourceCases() {
@@ -523,7 +522,7 @@ function loadHomePermissions(home: string) {
     const build = Agent.ID.make("build")
     yield* agents.transform((editor) => editor.update(build, () => {}))
     const entries = [
-      new Document({
+      new Config.Document({
         type: "document",
         info: decode(
           ConfigMigrateV1.migrate({

packages/core/test/config/command.test.ts

@@ -3,7 +3,7 @@ import path from "path"
 import { describe, expect } from "bun:test"
 import { Deferred, Effect, Fiber, Layer, Option, PubSub, Schema, Stream } from "effect"
 import { advance, drain } from "../lib/clock"
-import { Directory, Document, Event, Info } from "@opencode-ai/schema/config"
+import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { Command } from "@opencode-ai/core/command"
 import { Agent } from "@opencode-ai/core/agent"
 import { Config } from "@opencode-ai/core/config"
@@ -35,7 +35,7 @@ const it = testEffect(
     [Location.node, testLocationLayer],
   ]),
 )
-const decode = Schema.decodeUnknownSync(Info)
+const decode = Schema.decodeUnknownSync(Config.Info)
 
 describe("ConfigCommandPlugin.Plugin", () => {
   it.live("loads inline and file-based commands in config order", () =>
@@ -63,7 +63,7 @@ Review files`,
 
           const command = yield* Command.Service
           const bus = yield* Bus.Service
-          const update = yield* bus.publish(Event.Updated, {})
+          const update = yield* bus.publish(ConfigSchema.Event.Updated, {})
           const updates = yield* PubSub.unbounded<typeof update>()
           yield* ConfigCommandPlugin.Plugin.effect(
             host({
@@ -77,11 +77,11 @@ Review files`,
           ).pipe(
             Effect.provide(
               Config.testLayer([
-                new Document({
+                new Config.Document({
                   type: "document",
                   info: decode({ commands: { review: { template: "Inline review" } } }),
                 }),
-                new Directory({ type: "directory", path: AbsolutePath.make(tmp.path) }),
+                new Config.Directory({ type: "directory", path: AbsolutePath.make(tmp.path) }),
               ]),
             ),
           )
@@ -333,7 +333,7 @@ function watchReady(config: Config.Interface, directory: string) {
 }
 
 function directoryEntry(directory: string) {
-  return new Directory({ type: "directory", path: AbsolutePath.make(directory) })
+  return new Config.Directory({ type: "directory", path: AbsolutePath.make(directory) })
 }
 
 function sourceCases() {

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

@@ -4,9 +4,9 @@ import { describe, expect } from "bun:test"
 import { Effect, Fiber, Layer, PubSub, Schema, Stream } from "effect"
 import { FastCheck } from "effect/testing"
 import { Config } from "@opencode-ai/core/config"
-import { AgentsDirectory, Directory, Document, Event, Info } from "@opencode-ai/schema/config"
-import { ConfigModel } from "@opencode-ai/schema/config/model"
-import { ConfigProvider } from "@opencode-ai/schema/config/provider"
+import { ConfigModel } from "@opencode-ai/core/config/model"
+import { Config as ConfigSchema } from "@opencode-ai/schema/config"
+import { ConfigProvider } from "@opencode-ai/core/config/provider"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
@@ -161,7 +161,7 @@ describe("Config", () => {
             const bus = yield* Bus.Service
             const watcher = yield* Watcher.Test
             const changed = yield* bus
-              .subscribe(Event.Updated)
+              .subscribe(ConfigSchema.Event.Updated)
               .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
             yield* Effect.sleep("10 millis")
 
@@ -234,14 +234,14 @@ describe("Config", () => {
             yield* Effect.sleep("10 millis")
 
             const removed = yield* bus
-              .subscribe(Event.Updated)
+              .subscribe(ConfigSchema.Event.Updated)
               .pipe(Stream.take(1), Stream.runDrain, Effect.forkScoped({ startImmediately: true }))
             yield* Effect.promise(() => fs.rm(file))
             yield* Fiber.join(removed).pipe(Effect.timeout("5 seconds"))
             expect(Config.latest(yield* config.entries(), "shell")).toBeUndefined()
 
             const recreated = yield* bus
-              .subscribe(Event.Updated)
+              .subscribe(ConfigSchema.Event.Updated)
               .pipe(Stream.take(1), Stream.runDrain, Effect.forkScoped({ startImmediately: true }))
             yield* Effect.promise(() => fs.writeFile(file, JSON.stringify({ shell: "two" })))
             yield* Fiber.join(recreated).pipe(Effect.timeout("5 seconds"))
@@ -273,7 +273,7 @@ describe("Config", () => {
       const test = yield* Config.Test
       expect(yield* config.entries()).toEqual([])
 
-      const entry = new Document({ type: "document", info: new Info({}) })
+      const entry = new Config.Document({ type: "document", info: new Config.Info({}) })
       yield* test.setEntries([entry])
       expect(yield* config.entries()).toEqual([entry])
 
@@ -289,16 +289,16 @@ describe("Config", () => {
   it.effect("returns the latest defined scalar from priority-ordered documents", () =>
     Effect.sync(() => {
       const entries = [
-        new Document({
+        new Config.Document({
           type: "document",
-          info: new Info({ model: selection("openrouter/openai/gpt-5") }),
+          info: new Config.Info({ model: selection("openrouter/openai/gpt-5") }),
         }),
-        new Directory({ type: "directory", path: AbsolutePath.make("/skills") }),
-        new AgentsDirectory({ type: "agents", path: AbsolutePath.make("/agents") }),
-        new Document({ type: "document", info: new Info({}) }),
-        new Document({
+        new Config.Directory({ type: "directory", path: AbsolutePath.make("/skills") }),
+        new Config.AgentsDirectory({ type: "agents", path: AbsolutePath.make("/agents") }),
+        new Config.Document({ type: "document", info: new Config.Info({}) }),
+        new Config.Document({
           type: "document",
-          info: new Info({ model: selection("openrouter/openai/gpt-5.5") }),
+          info: new Config.Info({ model: selection("openrouter/openai/gpt-5.5") }),
         }),
       ]
 
@@ -372,7 +372,7 @@ describe("Config", () => {
             const bus = yield* Bus.Service
             expect(Config.latest(yield* config.entries(), "shell")).toBe("secret")
             const updated = yield* bus
-              .subscribe(Event.Updated)
+              .subscribe(ConfigSchema.Event.Updated)
               .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
             yield* Effect.yieldNow
             key = "next"
@@ -418,7 +418,7 @@ describe("Config", () => {
               Schema.encodeUnknownSync(Schema.UnknownFromJsonString)(info),
             ),
           )
-          Schema.decodeUnknownSync(Info)(ConfigMigrateV1.migrate(parsed), { errors: "all" })
+          Schema.decodeUnknownSync(Config.Info)(ConfigMigrateV1.migrate(parsed), { errors: "all" })
         }),
         { numRuns: 100 },
       )
@@ -661,45 +661,13 @@ describe("Config", () => {
           const entries = yield* config.entries()
 
           expect(entries).toEqual([
-            new Directory({ type: "directory", path: AbsolutePath.make(path.join(tmp.path, "global")) }),
+            new Config.Directory({ type: "directory", path: AbsolutePath.make(path.join(tmp.path, "global")) }),
           ])
         }).pipe(Effect.provide(testLayer(tmp.path))),
       ),
     ),
   )
 
-  it.live("deduplicates global ecosystem directories found during upward discovery", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const global = path.join(tmp.path, "global")
-          const home = path.join(global, "home")
-          const project = path.join(home, "project")
-          yield* Effect.promise(() =>
-            Promise.all([
-              fs.mkdir(path.join(home, ".claude"), { recursive: true }),
-              fs.mkdir(path.join(home, ".agents"), { recursive: true }),
-              fs.mkdir(project, { recursive: true }),
-            ]),
-          )
-          const entries = yield* Config.Service.use((config) => config.entries()).pipe(
-            Effect.provide(testLayer(project, global)),
-          )
-
-          expect(entries.filter((entry) => entry.type === "claude").map((entry) => entry.path)).toEqual([
-            AbsolutePath.make(path.join(home, ".claude")),
-          ])
-          expect(entries.filter((entry) => entry.type === "agents").map((entry) => entry.path)).toEqual([
-            AbsolutePath.make(path.join(home, ".agents")),
-          ])
-        }),
-      ),
-    ),
-  )
-
   it.live("does not watch ecosystem config roots", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
@@ -761,7 +729,7 @@ describe("Config", () => {
             expect(documents).toHaveLength(2)
             expect(documents.map((document) => document.type)).toEqual(["document", "document"])
             expect(documents.map((document) => document.info.$schema)).toEqual(["base", "last"])
-            expect(documents[0]).toBeInstanceOf(Document)
+            expect(documents[0]).toBeInstanceOf(Config.Document)
             expect(documents[0]?.path).toBe(path.join(tmp.path, "opencode.json"))
             expect(documents[1]?.info.providers?.last).toBeInstanceOf(ConfigProvider.Info)
 
@@ -1209,7 +1177,7 @@ describe("Config", () => {
             const documents = (yield* config.entries()).filter((entry) => entry.type === "document")
 
             expect(documents).toHaveLength(1)
-            expect(documents[0]?.info).toBeInstanceOf(Info)
+            expect(documents[0]?.info).toBeInstanceOf(Config.Info)
             expect(documents[0]?.info.shell).toBe("/bin/zsh")
             expect(documents[0]?.info.default_agent).toBe("reviewer")
             expect(documents[0]?.info.snapshots).toBe(false)

packages/core/test/config/model.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { ConfigModel } from "@opencode-ai/schema/config/model"
+import { ConfigModel } from "@opencode-ai/core/config/model"
 import { Model } from "@opencode-ai/schema/model"
 import { Provider } from "@opencode-ai/schema/provider"
 import { Schema } from "effect"

packages/core/test/config/policy.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect } from "bun:test"
-import { Document, Event, Info, type Entry } from "@opencode-ai/schema/config"
+import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Config } from "@opencode-ai/core/config"
 import { ConfigPolicyPlugin } from "@opencode-ai/core/config/plugin/policy"
@@ -12,10 +12,10 @@ import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "../plugin/fixture"
 
 const it = testEffect(PluginTestLayer)
-const decode = Schema.decodeUnknownSync(Info)
+const decode = Schema.decodeUnknownSync(Config.Info)
 
 const policies = (...items: { effect: "allow" | "deny"; resource: string }[]) =>
-  new Document({
+  new Config.Document({
     type: "document",
     info: decode({
       experimental: {
@@ -24,7 +24,7 @@ const policies = (...items: { effect: "allow" | "deny"; resource: string }[]) =>
     }),
   })
 
-const addPlugin = Effect.fn(function* (entries: Entry[]) {
+const addPlugin = Effect.fn(function* (entries: Config.Entry[]) {
   const plugin = yield* Plugin.Service
   const host = yield* PluginHost.make(plugin)
   yield* ConfigPolicyPlugin.Plugin.effect(host).pipe(Effect.provide(Config.testLayer(entries)))
@@ -78,7 +78,7 @@ describe("ConfigPolicyPlugin.Plugin", () => {
       expect(yield* catalog.provider.get(Provider.ID.openai)).toBeUndefined()
 
       yield* test.setEntries([policies({ effect: "allow", resource: "openai" })])
-      yield* bus.publish(Event.Updated, {})
+      yield* bus.publish(ConfigSchema.Event.Updated, {})
       yield* waitUntil(catalog.provider.get(Provider.ID.openai).pipe(Effect.map((provider) => provider !== undefined)))
     }).pipe(Effect.provide(Config.testLayer([policies({ effect: "deny", resource: "openai" })]))),
   )

packages/core/test/config/provider.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect } from "bun:test"
 import { Money } from "@opencode-ai/schema/money"
-import { Document, Info, type Entry } from "@opencode-ai/schema/config"
 import { Effect, Schema, Stream } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Config } from "@opencode-ai/core/config"
@@ -15,7 +14,7 @@ import { PluginTestLayer } from "../plugin/fixture"
 
 const it = testEffect(PluginTestLayer)
 
-const addPlugin = Effect.fn(function* (entries: Entry[]) {
+const addPlugin = Effect.fn(function* (entries: Config.Entry[]) {
   const plugin = yield* Plugin.Service
   const host = yield* PluginHost.make(plugin)
   yield* ConfigProviderPlugin.Plugin.effect(host).pipe(Effect.provide(Config.testLayer(entries)))
@@ -47,7 +46,7 @@ function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () =
   )
 }
 
-const decode = Schema.decodeUnknownSync(Info)
+const decode = Schema.decodeUnknownSync(Config.Info)
 
 describe("ConfigProviderPlugin.Plugin", () => {
   it.effect("defaults custom models to agent capabilities", () =>
@@ -56,7 +55,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
       const providerID = Provider.ID.make("custom")
       const modelID = Model.ID.make("chat")
       const entries = [
-        new Document({
+        new Config.Document({
           type: "document",
           info: decode({
             providers: {
@@ -91,7 +90,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
         })
       })
       const entries = [
-        new Document({
+        new Config.Document({
           type: "document",
           info: decode({
             providers: {
@@ -130,7 +129,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
       const providerID = Provider.ID.opencode
       const modelID = Model.ID.make("alpha-gpt-next")
       const entries = [
-        new Document({
+        new Config.Document({
           type: "document",
           info: decode({
             providers: {
@@ -179,7 +178,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
       const providerID = Provider.ID.opencode
       const modelID = Model.ID.make("alpha-gpt-next")
       const entries = [
-        new Document({
+        new Config.Document({
           type: "document",
           info: decode({
             providers: {
@@ -190,7 +189,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
             },
           }),
         }),
-        new Document({
+        new Config.Document({
           type: "document",
           info: decode({
             providers: {
@@ -224,7 +223,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
         const providerID = Provider.ID.make("custom")
         const modelID = Model.ID.make("chat")
         const entries = [
-          new Document({
+          new Config.Document({
             type: "document",
             info: decode({
               model: "custom/first",
@@ -256,7 +255,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
               },
             }),
           }),
-          new Document({
+          new Config.Document({
             type: "document",
             info: decode({
               model: "custom/default",
@@ -290,7 +289,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
               },
             }),
           }),
-          new Document({
+          new Config.Document({
             type: "document",
             info: decode({
               providers: {

packages/core/test/config/reload.test.ts

@@ -1,6 +1,6 @@
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Document, Event, Info } from "@opencode-ai/schema/config"
+import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Command } from "@opencode-ai/core/command"
@@ -22,7 +22,7 @@ import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "../plugin/fixture"
 
 const it = testEffect(PluginTestLayer)
-const decode = Schema.decodeUnknownSync(Info)
+const decode = Schema.decodeUnknownSync(Config.Info)
 const document = path.join(import.meta.dir, "opencode.json")
 
 describe("config plugin reloads", () => {
@@ -54,7 +54,7 @@ describe("config plugin reloads", () => {
 
       yield* test.setEntries([config("second")])
       yield* Effect.yieldNow
-      yield* bus.publish(Event.Updated, {})
+      yield* bus.publish(ConfigSchema.Event.Updated, {})
       yield* waitUntil(
         Effect.gen(function* () {
           return (
@@ -83,7 +83,7 @@ describe("config plugin reloads", () => {
 })
 
 function config(name: string) {
-  return new Document({
+  return new Config.Document({
     type: "document",
     path: document,
     info: decode({

packages/core/test/config/skill.test.ts

@@ -2,7 +2,6 @@ import path from "path"
 import { describe, expect } from "bun:test"
 import { Effect, Layer, Schema, Stream } from "effect"
 import { Config } from "@opencode-ai/core/config"
-import { AgentsDirectory, ClaudeDirectory, Directory, Document, Info } from "@opencode-ai/schema/config"
 import { ConfigSkillPlugin } from "@opencode-ai/core/config/plugin/skill"
 import { Global } from "@opencode-ai/util/global"
 import { Location } from "@opencode-ai/core/location"
@@ -13,7 +12,7 @@ import { testEffect } from "../lib/effect"
 import { host } from "../plugin/host"
 
 const it = testEffect(Layer.empty)
-const decode = Schema.decodeUnknownSync(Info)
+const decode = Schema.decodeUnknownSync(Config.Info)
 
 describe("ConfigSkillPlugin.Plugin", () => {
   it.effect("registers configured skill directories and URLs", () =>
@@ -44,10 +43,10 @@ describe("ConfigSkillPlugin.Plugin", () => {
         Effect.provideService(Location.Service, Location.Service.of(location({ directory }))),
         Effect.provide(
           Config.testLayer([
-            new ClaudeDirectory({ type: "claude", path: AbsolutePath.make("/repo/.claude") }),
-            new AgentsDirectory({ type: "agents", path: AbsolutePath.make("/repo/.agents") }),
-            new Directory({ type: "directory", path: AbsolutePath.make("/repo/.opencode") }),
-            new Document({
+            new Config.ClaudeDirectory({ type: "claude", path: AbsolutePath.make("/repo/.claude") }),
+            new Config.AgentsDirectory({ type: "agents", path: AbsolutePath.make("/repo/.agents") }),
+            new Config.Directory({ type: "directory", path: AbsolutePath.make("/repo/.opencode") }),
+            new Config.Document({
               type: "document",
               info: decode({
                 skills: ["./skills", "~/shared-skills", "/opt/skills", "https://example.test/skills/"],

packages/core/test/config/warming.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import { Duration, Schema } from "effect"
-import { Info } from "@opencode-ai/schema/config"
+import { Config } from "../../src/config"
 
-const decode = Schema.decodeUnknownSync(Info)
+const decode = Schema.decodeUnknownSync(Config.Info)
 
 describe("config warming", () => {
   test("accepts boolean enablement", () => {

packages/core/test/form.test.ts

@@ -15,7 +15,6 @@ const input = {
   id: formID,
   sessionID: SessionSchema.ID.make("ses_test"),
   title: "Test form",
-  coalesce: "test-form",
   fields: [{ key: "name", type: "string", required: true }],
 } satisfies Form.CreateInput
 
@@ -33,7 +32,6 @@ describe("Form", () => {
       yield* Effect.addFinalizer(() => unsubscribe)
       const fiber = yield* service.ask(input).pipe(Effect.forkScoped)
       const form = yield* Deferred.await(created)
-      expect(form.coalesce).toBe("test-form")
 
       yield* service.cancel(form.id)
 

packages/core/test/formatter.test.ts

@@ -5,7 +5,6 @@ import { Effect, Layer, Schema, Stream } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Npm } from "@opencode-ai/util/npm"
-import { Document, Info } from "@opencode-ai/schema/config"
 import { Config } from "../src/config"
 import { Formatter } from "../src/formatter"
 import { Location } from "../src/location"
@@ -14,16 +13,16 @@ import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
 
 const it = testEffect(Layer.empty)
-type ConfigInput = typeof Info.Encoded
+type ConfigInput = typeof Config.Info.Encoded
 
 function formatterLayer(directory: string, configured?: ConfigInput["formatter"]) {
   const entries =
     configured === undefined
       ? []
       : [
-          new Document({
+          new Config.Document({
             type: "document",
-            info: Schema.decodeUnknownSync(Info)({ formatter: configured }),
+            info: Schema.decodeUnknownSync(Config.Info)({ formatter: configured }),
           }),
         ]
   return AppNodeBuilder.build(Formatter.node, [

packages/core/test/mcp.test.ts

@@ -12,8 +12,7 @@ import {
   ListToolsRequestSchema,
   ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js"
-import { Document, Info } from "@opencode-ai/schema/config"
-import { ConfigMCP } from "@opencode-ai/schema/config/mcp"
+import { ConfigMCP } from "@opencode-ai/core/config/mcp"
 import { Config } from "@opencode-ai/core/config"
 import { Credential } from "@opencode-ai/core/credential"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -163,9 +162,9 @@ function resourceMcpLayer(
     Layer.provide(
       Layer.mergeAll(
         Config.testLayer([
-          new Document({
+          new Config.Document({
             type: "document",
-            info: new Info({
+            info: new Config.Info({
               mcp: new ConfigMCP.Info({
                 servers: {
                   resources:

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

@@ -1,7 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Cause, Deferred, Effect, Exit, Layer, Queue } from "effect"
 import { Config } from "@opencode-ai/core/config"
-import { Document, Info } from "@opencode-ai/schema/config"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
@@ -214,7 +213,7 @@ const configuredIt = testEffect(
         entries: () =>
           Effect.succeed(
             configuredShell
-              ? [new Document({ type: "document", info: new Info({ shell: configuredShell }) })]
+              ? [new Config.Document({ type: "document", info: new Config.Info({ shell: configuredShell }) })]
               : [],
           ),
       }),

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

@@ -23,6 +23,7 @@ import { SessionPending } from "@opencode-ai/core/session/pending"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
+import { SessionTransfer } from "@opencode-ai/core/session/transfer"
 import { Workspace } from "@opencode-ai/core/workspace"
 import { testEffect } from "./lib/effect"
 import { tmpdir } from "./fixture/tmpdir"
@@ -37,7 +38,14 @@ const projects = Layer.succeed(
 )
 const it = testEffect(
   AppNodeBuilder.build(
-    LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, Session.node]),
+    LayerNode.group([
+      Database.node,
+      Bus.node,
+      SessionProjector.node,
+      SessionStore.node,
+      Session.node,
+      SessionTransfer.node,
+    ]),
     [
       [Bus.node, Bus.configured({ persist: true })],
       [Project.node, projects],
@@ -740,3 +748,77 @@ describe("Session.create", () => {
     }),
   )
 })
+
+describe("SessionTransfer", () => {
+  it.effect("imports projected messages and reserves their aggregate sequence", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const transfer = yield* SessionTransfer.Service
+      const bus = yield* Bus.Service
+      const { db } = yield* Database.Service
+      const template = yield* session.create({ location, title: "Exported" })
+      const sessionID = Session.ID.create()
+      const sourceMessageID = SessionMessage.ID.create()
+      const errorMessageID = SessionMessage.ID.create()
+
+      const imported = yield* transfer.import({
+        data: {
+          info: { ...template, id: sessionID },
+          messages: [
+            {
+              id: sourceMessageID,
+              type: "user",
+              text: "Imported message",
+              time: { created: DateTime.makeUnsafe(100) },
+            },
+            {
+              id: errorMessageID,
+              type: "compaction",
+              status: "failed",
+              reason: "manual",
+              error: { type: "test_error", message: "Original error" },
+              time: { created: DateTime.makeUnsafe(101) },
+            },
+          ],
+        },
+        location,
+      })
+      const messages = yield* session.messages({ sessionID, order: "asc" })
+
+      expect(imported).toMatchObject({ id: sessionID, title: "Exported", location })
+      expect(messages).toMatchObject([
+        { id: sourceMessageID, type: "user", text: "Imported message" },
+        { id: errorMessageID, type: "compaction", error: { type: "test_error", message: "Original error" } },
+      ])
+      expect(yield* Bus.latestSequence(db, sessionID)).toBe(2)
+      expect((yield* transfer.export({ sessionID })).messages).toEqual(messages)
+      expect((yield* transfer.export({ sessionID, sanitize: true })).messages).toMatchObject([
+        { id: sourceMessageID, text: `[redacted:text:${sourceMessageID}]` },
+        { id: errorMessageID, error: { type: "test_error", message: "Original error" } },
+      ])
+
+      yield* session.prompt({ sessionID, text: "Continue", resume: false })
+      yield* SessionPending.promote(db, bus, sessionID, "steer")
+
+      expect((yield* session.messages({ sessionID, order: "asc" })).map((message) => message.type)).toEqual([
+        "user",
+        "compaction",
+        "user",
+      ])
+      expect(yield* Bus.latestSequence(db, sessionID)).toBe(4)
+    }),
+  )
+
+  it.effect("rejects an existing session ID without changing its transcript", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const transfer = yield* SessionTransfer.Service
+      const existing = yield* session.create({ location, title: "Existing" })
+      const exit = yield* Effect.exit(transfer.import({ data: { info: existing, messages: [] }, location }))
+
+      expect(exit._tag).toBe("Failure")
+      expect((yield* session.get(existing.id)).title).toBe("Existing")
+      expect(yield* session.messages({ sessionID: existing.id })).toEqual([])
+    }),
+  )
+})

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

@@ -49,10 +49,9 @@ import { SystemPromptPlugin } from "@opencode-ai/core/plugin/system-prompt"
 import { QuestionTool } from "@opencode-ai/core/tool/plugin/question"
 import { Agent } from "@opencode-ai/core/agent"
 import { Config } from "@opencode-ai/core/config"
-import { Document, Info } from "@opencode-ai/schema/config"
-import { ConfigCompaction } from "@opencode-ai/schema/config/compaction"
+import { ConfigCompaction } from "@opencode-ai/core/config/compaction"
 import { Tool } from "@opencode-ai/core/tool"
-import type { Info as ToolInfo } from "@opencode-ai/schema/tool"
+import type { Info } from "@opencode-ai/schema/tool"
 import {
   InstructionStateTable,
   SessionPendingTable,
@@ -229,7 +228,7 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const transformTools = (registry: Tool.Interface, tools: Readonly<Record<string, ToolInfo>>, options?: Tool.Options) =>
+const transformTools = (registry: Tool.Interface, tools: Readonly<Record<string, Info>>, options?: Tool.Options) =>
   registry.transform((draft) =>
     Object.entries(tools).forEach(([name, tool]) => draft.add({ ...tool, name, options: options ?? tool.options })),
   )
@@ -335,9 +334,9 @@ const referenceInstructions = Layer.mock(ReferenceInstructions.Service, {
 })
 const mcpInstructions = Layer.mock(McpInstructions.Service, { load: () => Effect.succeed(Instructions.empty) })
 const config = Config.testLayer([
-  new Document({
+  new Config.Document({
     type: "document",
-    info: new Info({
+    info: new Config.Info({
       compaction: new ConfigCompaction.Info({
         buffer: 3_000,
         keep: new ConfigCompaction.Keep({ tokens: 1_000 }),

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

@@ -2,8 +2,7 @@ import { beforeEach, describe, expect } from "bun:test"
 import path from "path"
 import { Effect, Exit, Layer, PlatformError, Stream } from "effect"
 import { Config } from "@opencode-ai/core/config"
-import { Document, Info } from "@opencode-ai/schema/config"
-import { ConfigMedia } from "@opencode-ai/schema/config/media"
+import { ConfigMedia } from "@opencode-ai/core/config/media"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FileSystem } from "@opencode-ai/core/filesystem"
@@ -430,9 +429,9 @@ describe("ReadTool", () => {
       }
       const configTest = yield* Config.Test
       yield* configTest.setEntries([
-        new Document({
+        new Config.Document({
           type: "document",
-          info: new Info({
+          info: new Config.Info({
             media: new ConfigMedia.Info({
               image: new ConfigMedia.Image({ auto_resize: false, max_width: 4 }),
             }),
@@ -473,9 +472,9 @@ describe("ReadTool", () => {
       }
       const configTest = yield* Config.Test
       yield* configTest.setEntries([
-        new Document({
+        new Config.Document({
           type: "document",
-          info: new Info({
+          info: new Config.Info({
             media: new ConfigMedia.Info({ image: new ConfigMedia.Image({ max_width: 4 }) }),
           }),
         }),
@@ -512,9 +511,9 @@ describe("ReadTool", () => {
       }
       const configTest = yield* Config.Test
       yield* configTest.setEntries([
-        new Document({
+        new Config.Document({
           type: "document",
-          info: new Info({
+          info: new Config.Info({
             media: new ConfigMedia.Info({
               image: new ConfigMedia.Image({ max_base64_bytes: 1 }),
             }),

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

@@ -241,7 +241,6 @@ describe("WebSearchTool registration", () => {
         {
           sessionID,
           title: "Web Search",
-          coalesce: "msg_tool_test:websearch-consent",
           metadata: { kind: "websearch.provider" },
           fields: [
             {
@@ -299,7 +298,6 @@ describe("WebSearchTool registration", () => {
       expect(formRequests[1]).toEqual({
         sessionID,
         title: "Choose a web search provider",
-        coalesce: "msg_tool_test:websearch-provider",
         metadata: { kind: "websearch.provider" },
         fields: [
           {

packages/protocol/src/api.ts

@@ -32,7 +32,6 @@ import { ProjectGroup } from "./groups/project.js"
 import { ProjectCopyGroup } from "./groups/project-copy.js"
 import { VcsGroup } from "./groups/vcs.js"
 import { MigrationGroup } from "./groups/migration.js"
-import { ConfigGroup } from "./groups/config.js"
 
 type LocationGroups<LocationId extends HttpApiMiddleware.AnyId> =
   | HttpApiGroup.AddMiddleware<typeof LocationGroup, LocationId>
@@ -54,7 +53,6 @@ type LocationGroups<LocationId extends HttpApiMiddleware.AnyId> =
   | HttpApiGroup.AddMiddleware<typeof ReferenceGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof ProjectCopyGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof VcsGroup, LocationId>
-  | HttpApiGroup.AddMiddleware<typeof ConfigGroup, LocationId>
 
 type SessionGroups<SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService> =
   | ReturnType<typeof makeSessionGroup<SessionLocationId, SessionLocationService>>
@@ -177,7 +175,6 @@ const makeApiFromGroup = <
     .add(DebugGroup)
     .add(MigrationGroup)
     .add(WebSearchGroup.middleware(locationMiddleware))
-    .add(ConfigGroup.middleware(locationMiddleware))
     .annotateMerge(
       OpenApi.annotations({
         title: "opencode HttpApi",

packages/protocol/src/client.ts

@@ -62,7 +62,6 @@ export const groupNames = {
   "server.project": "project",
   "server.projectCopy": "projectCopy",
   "server.vcs": "vcs",
-  "server.config": "config",
 } as const
 
 export const promiseOmitEndpoints = new Set(["pty.connect", "pty.connectToken"])

packages/protocol/src/groups/config.ts

@@ -1,22 +0,0 @@
-import { Config } from "@opencode-ai/schema/config"
-import { Schema } from "effect"
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location.js"
-
-export const ConfigGroup = HttpApiGroup.make("server.config")
-  .add(
-    HttpApiEndpoint.get("config.get", "/api/config", {
-      query: LocationQuery,
-      success: Schema.Array(Config.Entry),
-    })
-      .annotateMerge(locationQueryOpenApi)
-      .annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.config.get",
-          summary: "Get configuration",
-          description:
-            "Return configuration documents and discovery sources for the requested location, from lowest to highest priority.",
-        }),
-      ),
-  )
-  .annotateMerge(OpenApi.annotations({ title: "config", description: "Location-scoped configuration routes." }))

packages/protocol/src/groups/session.ts

@@ -1,4 +1,5 @@
 import { SessionMessage } from "@opencode-ai/schema/session-message"
+import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
 import { SessionPending } from "@opencode-ai/schema/session-pending"
 import { PromptInput } from "@opencode-ai/schema/prompt-input"
 import { Session } from "@opencode-ai/schema/session"
@@ -163,6 +164,36 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         }),
       ),
     )
+    .add(
+      HttpApiEndpoint.post("session.import", "/api/session/import", {
+        payload: Schema.Struct({
+          ...SessionTransfer.Data.fields,
+          location: Location.Ref.pipe(Schema.optional),
+        }),
+        success: Schema.Struct({ data: Session.Info }),
+        error: ConflictError,
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.session.import",
+          summary: "Import session",
+          description: "Import a projected session transcript at the requested location.",
+        }),
+      ),
+    )
+    .add(
+      HttpApiEndpoint.get("session.export", "/api/session/:sessionID/export", {
+        params: { sessionID: Session.ID },
+        query: Schema.Struct({ sanitize: BooleanFromString.pipe(Schema.optional) }),
+        success: Schema.Struct({ data: SessionTransfer.Data }),
+        error: [SessionNotFoundError, UnknownError],
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.session.export",
+          summary: "Export session",
+          description: "Export a complete projected session transcript.",
+        }),
+      ),
+    )
     .add(
       HttpApiEndpoint.get("session.active", "/api/session/active", {
         success: Schema.Struct({ data: Schema.Record(Session.ID, SessionActive) }),

packages/schema/src/config.ts

@@ -1,142 +1,6 @@
 export * as Config from "./config.js"
 
-import { Schema } from "effect"
 import { ephemeral, inventory } from "./event.js"
-import { Permission } from "./permission.js"
-import { AbsolutePath } from "./schema.js"
-import { ConfigAgent } from "./config/agent.js"
-import { ConfigMedia } from "./config/media.js"
-import { ConfigCompaction } from "./config/compaction.js"
-import { ConfigCommand } from "./config/command.js"
-import { ConfigExperimental } from "./config/experimental.js"
-import { ConfigFormatter } from "./config/formatter.js"
-import { ConfigLSP } from "./config/lsp.js"
-import { ConfigMCP } from "./config/mcp.js"
-import { ConfigModel } from "./config/model.js"
-import { ConfigPlugin } from "./config/plugin.js"
-import { ConfigProvider } from "./config/provider.js"
-import { ConfigReference } from "./config/reference.js"
-import { ConfigWebSearch } from "./config/websearch.js"
-import { ConfigToolOutput } from "./config/tool-output.js"
-import { ConfigWatcher } from "./config/watcher.js"
-import { ConfigWarming } from "./config/warming.js"
-
-export class Info extends Schema.Class<Info>("Config.Info")({
-  $schema: Schema.optional(Schema.String).annotate({
-    description: "JSON schema reference for configuration validation",
-  }),
-  shell: Schema.String.pipe(Schema.optional).annotate({
-    description: "Default shell to use for terminal and shell tool execution",
-  }),
-  model: ConfigModel.Selection.pipe(Schema.optional).annotate({
-    description: "Default model to use when no session or agent model is selected",
-  }),
-  default_agent: Schema.String.pipe(Schema.optional).annotate({
-    description: "Default primary agent to use when no session agent is selected",
-  }),
-  autoupdate: Schema.Union([Schema.Boolean, Schema.Literal("notify")])
-    .pipe(Schema.optional)
-    .annotate({
-      description: "Automatically update or notify when a new version is available",
-    }),
-  share: Schema.Literals(["manual", "auto", "disabled"]).pipe(Schema.optional).annotate({
-    description: "Control whether sessions may be shared manually, automatically, or not at all",
-  }),
-  enterprise: Schema.Struct({
-    url: Schema.String.pipe(Schema.optional),
-  })
-    .pipe(Schema.optional)
-    .annotate({
-      description: "Enterprise sharing service configuration",
-    }),
-  username: Schema.String.pipe(Schema.optional).annotate({
-    description: "Username displayed in conversations and used for telemetry identity",
-  }),
-  permissions: Permission.Ruleset.pipe(Schema.optional).annotate({
-    description: "Ordered tool permission rules applied to agent tool use",
-  }),
-  agents: Schema.Record(Schema.String, ConfigAgent.Info).pipe(Schema.optional).annotate({
-    description: "Named built-in agent overrides and custom agent definitions",
-  }),
-  snapshots: Schema.Boolean.pipe(Schema.optional).annotate({
-    description: "Enable snapshots used for undo and revert behavior",
-  }),
-  watcher: ConfigWatcher.Info.pipe(Schema.optional).annotate({
-    description: "Filesystem watcher configuration",
-  }),
-  formatter: ConfigFormatter.Info.pipe(Schema.optional).annotate({
-    description: "Enable built-in formatters or configure formatter overrides",
-  }),
-  lsp: ConfigLSP.Info.pipe(Schema.optional).annotate({
-    description: "Enable built-in language servers or configure server overrides",
-  }),
-  media: ConfigMedia.Info.pipe(Schema.optional).annotate({
-    description: "Media processing configuration",
-  }),
-  tool_output: ConfigToolOutput.Info.pipe(Schema.optional).annotate({
-    description: "Tool output truncation thresholds",
-  }),
-  mcp: ConfigMCP.Info.pipe(Schema.optional).annotate({
-    description: "MCP server configuration",
-  }),
-  compaction: ConfigCompaction.Info.pipe(Schema.optional).annotate({
-    description: "Conversation compaction behavior",
-  }),
-  skills: Schema.String.pipe(Schema.Array, Schema.optional).annotate({
-    description: "Additional paths or URLs to discover skills from",
-  }),
-  commands: Schema.Record(Schema.String, ConfigCommand.Info).pipe(Schema.optional).annotate({
-    description: "Named slash command definitions",
-  }),
-  instructions: Schema.String.pipe(Schema.Array, Schema.optional).annotate({
-    description: "Additional paths or URLs supplying ambient instructions",
-  }),
-  references: ConfigReference.Info.pipe(Schema.optional).annotate({
-    description: "Named local directories or Git repositories available as external context",
-  }),
-  websearch: ConfigWebSearch.Info.pipe(Schema.optional).annotate({
-    description: "Web search provider selection",
-  }),
-  plugins: ConfigPlugin.Plugins.pipe(Schema.optional).annotate({
-    description: "Ordered plugin enablement directives and external package declarations",
-  }),
-  warming: ConfigWarming.Warming.pipe(Schema.optional).annotate({
-    description: "Keep recently active sessions warm with transient model requests (default: false)",
-  }),
-  providers: Schema.Record(Schema.String, ConfigProvider.Info).pipe(Schema.optional),
-  experimental: ConfigExperimental.Info.pipe(Schema.optional),
-}) {}
-
-export class Document extends Schema.Class<Document>("Config.Document")({
-  type: Schema.Literal("document"),
-  path: Schema.String.pipe(Schema.optional),
-  info: Info,
-}) {}
-
-export class Directory extends Schema.Class<Directory>("Config.Directory")({
-  type: Schema.Literal("directory"),
-  path: AbsolutePath,
-}) {}
-
-export class File extends Schema.Class<File>("Config.File")({
-  type: Schema.Literal("file"),
-  path: AbsolutePath,
-}) {}
-
-export class AgentsDirectory extends Schema.Class<AgentsDirectory>("Config.AgentsDirectory")({
-  type: Schema.Literal("agents"),
-  path: AbsolutePath,
-}) {}
-
-export class ClaudeDirectory extends Schema.Class<ClaudeDirectory>("Config.ClaudeDirectory")({
-  type: Schema.Literal("claude"),
-  path: AbsolutePath,
-}) {}
-
-export const Entry = Schema.Union([Document, Directory, File, AgentsDirectory, ClaudeDirectory]).annotate({
-  identifier: "Config.Entry",
-})
-export type Entry = typeof Entry.Type
 
 const Updated = ephemeral({
   type: "config.updated",

packages/schema/src/form.ts

@@ -124,9 +124,6 @@ const InfoBase = {
   // on non-session owners anywhere else.
   sessionID: Schema.String,
   title: Schema.String,
-  coalesce: Schema.String.pipe(optional).annotate({
-    description: "Client-local key for displaying equivalent pending forms once and broadcasting one response.",
-  }),
   metadata: Metadata.pipe(optional),
 }
 

packages/schema/src/index.ts

@@ -25,6 +25,7 @@ export { Vcs } from "./vcs.js"
 export { SessionPending } from "./session-pending.js"
 export { SessionError } from "./session-error.js"
 export { SessionMessage } from "./session-message.js"
+export { SessionTransfer } from "./session-transfer.js"
 export { Snapshot } from "./snapshot.js"
 export { Shell } from "./shell.js"
 export { Skill } from "./skill.js"

packages/schema/src/session-transfer.ts

@@ -0,0 +1,11 @@
+export * as SessionTransfer from "./session-transfer.js"
+
+import { Schema } from "effect"
+import { Session } from "./session.js"
+import { SessionMessage } from "./session-message.js"
+
+export interface Data extends Schema.Schema.Type<typeof Data> {}
+export const Data = Schema.Struct({
+  info: Session.Info,
+  messages: Schema.Array(SessionMessage.Info),
+}).annotate({ identifier: "SessionTransfer.Data" })

packages/schema/test/config.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { Config } from "../src/config.js"
-import { AbsolutePath } from "../src/schema.js"
-
-describe("Config.Entry", () => {
-  test("round-trips every configuration entry type", () => {
-    const entries = [
-      new Config.Document({
-        type: "document",
-        path: "/project/opencode.json",
-        info: new Config.Info({
-          permissions: [
-            { action: "shell", resource: "*", effect: "ask" },
-            { action: "shell", resource: "git status", effect: "allow" },
-          ],
-        }),
-      }),
-      new Config.Document({ type: "document", info: new Config.Info({ shell: "/bin/zsh" }) }),
-      new Config.Directory({ type: "directory", path: AbsolutePath.make("/project/.opencode") }),
-      new Config.File({ type: "file", path: AbsolutePath.make("/project/opencode.json") }),
-      new Config.AgentsDirectory({ type: "agents", path: AbsolutePath.make("/project/.agents") }),
-      new Config.ClaudeDirectory({ type: "claude", path: AbsolutePath.make("/project/.claude") }),
-    ]
-
-    const encoded = Schema.encodeSync(Schema.Array(Config.Entry))(entries)
-    const decoded = Schema.decodeUnknownSync(Schema.Array(Config.Entry))(encoded)
-
-    expect(decoded).toEqual(entries)
-    expect(decoded[0]).toBeInstanceOf(Config.Document)
-    expect(decoded[1]).not.toHaveProperty("path")
-    expect(decoded.map((entry) => entry.type)).toEqual(["document", "document", "directory", "file", "agents", "claude"])
-    expect(decoded[0]?.type === "document" ? decoded[0].info.permissions : undefined).toEqual([
-      { action: "shell", resource: "*", effect: "ask" },
-      { action: "shell", resource: "git status", effect: "allow" },
-    ])
-  })
-
-  test("has a stable public identifier", () => {
-    expect(Config.Entry.ast.annotations?.identifier).toBe("Config.Entry")
-  })
-})

packages/sdk-next/src/index.ts

@@ -5,7 +5,6 @@ export { ClientError } from "@opencode-ai/client/effect"
 export type { OpenCodeEvent } from "@opencode-ai/client/effect"
 export { Agent } from "@opencode-ai/schema/agent"
 export { Command } from "@opencode-ai/schema/command"
-export { Config } from "@opencode-ai/schema/config"
 export { Credential } from "@opencode-ai/schema/credential"
 export { FileSystem } from "@opencode-ai/schema/filesystem"
 export { Integration } from "@opencode-ai/schema/integration"

packages/sdk-next/test/contract-identity.test.ts

@@ -3,7 +3,6 @@ import { Location as CoreLocation } from "@opencode-ai/core/location"
 import { SessionPending as CoreSessionPending } from "@opencode-ai/core/session/pending"
 import { SessionMessage as CoreSessionMessage } from "@opencode-ai/core/session/message"
 import { Agent } from "@opencode-ai/schema/agent"
-import { Config } from "@opencode-ai/schema/config"
 import { Location } from "@opencode-ai/schema/location"
 import { Model } from "@opencode-ai/schema/model"
 import { Project } from "@opencode-ai/schema/project"
@@ -25,7 +24,6 @@ const CoreSession = await import("@opencode-ai/core/session")
 
 test("re-exports canonical contracts directly from Schema", () => {
   expect(SDK.Agent).toBe(Agent)
-  expect(SDK.Config).toBe(Config)
   expect(SDK.Model).toBe(Model)
   expect(SDK.WebSearch).toBe(WebSearch)
   expect(SDK.Session).toBe(Session)
@@ -34,7 +32,6 @@ test("re-exports canonical contracts directly from Schema", () => {
     "Agent",
     "ClientError",
     "Command",
-    "Config",
     "Credential",
     "FileSystem",
     "Integration",

packages/server/src/handlers.ts

@@ -29,7 +29,6 @@ import { ProjectCopyHandler } from "./handlers/project-copy"
 import { VcsHandler } from "./handlers/vcs"
 import { EventFeed } from "./event-feed"
 import { MigrationHandler } from "./handlers/migration"
-import { ConfigHandler } from "./handlers/config"
 
 export const handlers = Layer.mergeAll(
   HealthHandler,
@@ -61,5 +60,4 @@ export const handlers = Layer.mergeAll(
   ReferenceHandler,
   ProjectCopyHandler,
   VcsHandler,
-  ConfigHandler,
 )

packages/server/src/handlers/config.ts

@@ -1,7 +0,0 @@
-import { Config } from "@opencode-ai/core/config"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Api } from "../api"
-
-export const ConfigHandler = HttpApiBuilder.group(Api, "server.config", (handlers) =>
-  handlers.handle("config.get", () => Config.Service.use((config) => config.entries())),
-)

packages/server/src/handlers/session.ts

@@ -1,4 +1,5 @@
 import { Session } from "@opencode-ai/core/session"
+import { SessionTransfer } from "@opencode-ai/core/session/transfer"
 import { InstructionEntry } from "@opencode-ai/core/session/instruction-entry"
 import { DateTime, Effect, Stream } from "effect"
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
@@ -24,6 +25,7 @@ const DefaultSessionsLimit = 50
 export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handlers) =>
   Effect.gen(function* () {
     const session = yield* Session.Service
+    const transfer = yield* SessionTransfer.Service
 
     return handlers
       .handle(
@@ -86,6 +88,56 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           }
         }),
       )
+      .handle(
+        "session.import",
+        Effect.fn(function* (ctx) {
+          return {
+            data: yield* transfer
+              .import({
+                data: { info: ctx.payload.info, messages: ctx.payload.messages },
+                location: ctx.payload.location ?? { directory: AbsolutePath.make(process.cwd()) },
+              })
+              .pipe(
+                Effect.catchTag(
+                  "SessionTransfer.ImportConflictError",
+                  (error) =>
+                    new ConflictError({
+                      message: `Session already exists: ${error.sessionID}`,
+                      resource: error.sessionID,
+                    }),
+                ),
+              ),
+          }
+        }),
+      )
+      .handle(
+        "session.export",
+        Effect.fn(function* (ctx) {
+          return {
+            data: yield* transfer.export({ sessionID: ctx.params.sessionID, sanitize: ctx.query.sanitize }).pipe(
+              Effect.catchTag(
+                "Session.NotFoundError",
+                (error) =>
+                  new SessionNotFoundError({
+                    sessionID: error.sessionID,
+                    message: `Session not found: ${error.sessionID}`,
+                  }),
+              ),
+              Effect.catchTag("Session.MessageDecodeError", (error) => {
+                const ref = `err_${crypto.randomUUID().slice(0, 8)}`
+                return Effect.logError("failed to decode session message").pipe(
+                  Effect.annotateLogs({ ref, sessionID: error.sessionID, messageID: error.messageID }),
+                  Effect.andThen(
+                    Effect.fail(
+                      new UnknownError({ message: "Unexpected server error. Check server logs for details.", ref }),
+                    ),
+                  ),
+                )
+              }),
+            ),
+          }
+        }),
+      )
       .handle(
         "session.active",
         Effect.fn(function* () {

packages/server/src/routes.ts

@@ -16,6 +16,7 @@ import { PtyTicket } from "@opencode-ai/core/pty/ticket"
 import { Pty } from "@opencode-ai/core/pty"
 import { Project } from "@opencode-ai/core/project"
 import { Session } from "@opencode-ai/core/session"
+import { SessionTransfer } from "@opencode-ai/core/session/transfer"
 import { Shell } from "@opencode-ai/core/shell"
 import { Job } from "@opencode-ai/core/job"
 import { MCP } from "@opencode-ai/core/mcp/index"
@@ -51,6 +52,7 @@ const applicationServices = LayerNode.group([
   Job.node,
   Project.node,
   Session.node,
+  SessionTransfer.node,
   PluginRuntime.providerNode,
   SdkPlugins.node,
   PermissionSaved.node,

packages/server/test/config.test.ts

@@ -1,62 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import { expect } from "bun:test"
-import { Config } from "@opencode-ai/schema/config"
-import { Effect, Schema } from "effect"
-import { HttpServer } from "effect/unstable/http"
-import { tmpdir } from "../../core/test/fixture/tmpdir"
-import { it } from "../../core/test/lib/effect"
-import { ServerProcess } from "../src/process"
-
-it.live("returns ordered config entries for the requested directory", () =>
-  Effect.acquireUseRelease(
-    Effect.promise(() => tmpdir("opencode-config-endpoint-")),
-    (tmp) =>
-      Effect.gen(function* () {
-        const global = path.join(tmp.path, "global")
-        const project = path.join(tmp.path, "project")
-        const config = path.join(project, "opencode.json")
-        yield* Effect.promise(() => Promise.all([fs.mkdir(global, { recursive: true }), fs.mkdir(project, { recursive: true })]))
-        yield* Effect.promise(() =>
-          fs.writeFile(
-            config,
-            JSON.stringify({
-              permissions: [
-                { action: "shell", resource: "*", effect: "ask" },
-                { action: "shell", resource: "git status", effect: "allow" },
-              ],
-            }),
-          ),
-        )
-        const server = yield* ServerProcess.start<never, never>({
-          hostname: "127.0.0.1",
-          port: 0,
-          password: "secret",
-          app: { version: "test-version" },
-          database: { path: ":memory:" },
-          config: { directory: global },
-          fs: { filewatcher: false },
-        })
-        const url = new URL("/api/config", HttpServer.formatAddress(server.address))
-        url.searchParams.set("location[directory]", project)
-        const response = yield* Effect.promise(() =>
-          fetch(url, { headers: { authorization: `Basic ${btoa("opencode:secret")}` } }),
-        )
-        const entries = Schema.decodeUnknownSync(Schema.Array(Config.Entry))(
-          yield* Effect.promise(() => response.json()),
-        )
-
-        expect(response.status).toBe(200)
-        expect(Array.isArray(entries)).toBe(true)
-        const document = entries.find(
-          (entry): entry is Config.Document => entry.type === "document" && entry.path === config,
-        )
-        expect(document?.info.permissions).toEqual([
-          { action: "shell", resource: "*", effect: "ask" },
-          { action: "shell", resource: "git status", effect: "allow" },
-        ])
-        expect(entries.some((entry) => entry.type === "file" && entry.path === config)).toBe(true)
-      }),
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  ),
-)

packages/tui/src/routes/home.tsx

@@ -93,13 +93,13 @@ export function Home() {
       <box width="100%" flexShrink={0}>
         <PluginSlot name="home.footer" input={{}} mode="replace" />
       </box>
-      <Show when={forms()[0]?.coalesce ?? forms()[0]?.id} keyed>
+      <Show when={forms()[0]?.id} keyed>
         {(_) => {
           const form = forms()[0]
           return form ? (
             <box position="absolute" zIndex={2000} left={0} right={0} bottom={1} paddingLeft={2} paddingRight={2}>
               <box width="100%">
-                <FormPrompt form={form} forms={forms()} />
+                <FormPrompt form={form} />
               </box>
             </box>
           ) : null

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

@@ -42,7 +42,7 @@ function requestOptions(form: FormWithLocation) {
   }
 }
 
-export function FormPrompt(props: { form: FormWithLocation; forms?: readonly FormWithLocation[] }) {
+export function FormPrompt(props: { form: FormWithLocation }) {
   const client = useClient()
   const themes = useThemes()
   const theme = useTheme("elevated")
@@ -69,11 +69,6 @@ export function FormPrompt(props: { form: FormWithLocation; forms?: readonly For
   let textarea: TextareaRenderable | undefined
   let review: ScrollBoxRenderable | undefined
 
-  const forms = createMemo(() => {
-    if (!props.form.coalesce) return [props.form]
-    return (props.forms ?? [props.form]).filter((form) => form.coalesce === props.form.coalesce)
-  })
-
   const message = createMemo(() => {
     const value = props.form.metadata?.["message"]
     return typeof value === "string" ? value : undefined
@@ -185,30 +180,24 @@ export function FormPrompt(props: { form: FormWithLocation; forms?: readonly For
     setStore("error", "")
   }
 
-  function reply(answer: Record<string, FormValue>) {
-    Promise.all(
-      forms().map((form) =>
-        client.api.form.reply(
-          {
-            sessionID: form.sessionID,
-            formID: form.id,
-            answer,
-          },
-          requestOptions(form),
-        ),
-      ),
-    ).catch((error: unknown) => {
-      setStore(
-        "error",
-        typeof error === "object" && error !== null && "message" in error && typeof error.message === "string"
-          ? error.message
-          : "Invalid answer",
-      )
-    })
-  }
-
   function replySingle(field: FormAnswerField, value: FormValue) {
-    reply({ [field.key]: value })
+    client.api.form
+      .reply(
+        {
+          sessionID: props.form.sessionID,
+          formID: props.form.id,
+          answer: { [field.key]: value },
+        },
+        requestOptions(props.form),
+      )
+      .catch((error: unknown) => {
+        setStore(
+          "error",
+          typeof error === "object" && error !== null && "message" in error && typeof error.message === "string"
+            ? error.message
+            : "Invalid answer",
+        )
+      })
   }
 
   function pick(value: FormValue, customValue?: string) {
@@ -361,8 +350,7 @@ export function FormPrompt(props: { form: FormWithLocation; forms?: readonly For
   }
 
   function cancel() {
-    for (const form of forms())
-      void client.api.form.cancel({ sessionID: form.sessionID, formID: form.id }, requestOptions(form))
+    void client.api.form.cancel({ sessionID: props.form.sessionID, formID: props.form.id }, requestOptions(props.form))
   }
 
   function openExternal() {
@@ -414,14 +402,28 @@ export function FormPrompt(props: { form: FormWithLocation; forms?: readonly For
       setStore("error", formValidateValue(invalid, store.answers[invalid.key]) ?? "Invalid answer")
       return
     }
-    reply(
-      Object.fromEntries(
-        fields().flatMap((field) => {
-          const value = store.answers[field.key]
-          return value === undefined ? [] : [[field.key, value] as const]
-        }),
-      ),
-    )
+    client.api.form
+      .reply(
+        {
+          sessionID: props.form.sessionID,
+          formID: props.form.id,
+          answer: Object.fromEntries(
+            fields().flatMap((field) => {
+              const value = store.answers[field.key]
+              return value === undefined ? [] : [[field.key, value] as const]
+            }),
+          ),
+        },
+        requestOptions(props.form),
+      )
+      .catch((error: unknown) => {
+        setStore(
+          "error",
+          typeof error === "object" && error !== null && "message" in error && typeof error.message === "string"
+            ? error.message
+            : "Invalid answer",
+        )
+      })
   }
 
   onMount(() => onCleanup(keymap.mode.push(FORM_MODE)))

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

@@ -824,22 +824,13 @@ export function Session() {
           if (options === null) return
 
           const content =
-            options.format === "markdown"
-              ? formatSessionTranscript(sessionData, messages(), options.thinking)
-              : await (async () => {
-                  const messages: unknown[] = []
-                  let cursor: string | undefined
-                  do {
-                    const page = await client.api.message.list(
-                      cursor
-                        ? { sessionID: sessionData.id, limit: 200, cursor }
-                        : { sessionID: sessionData.id, limit: 200, order: "asc" },
-                    )
-                    messages.push(...page.data)
-                    cursor = page.data.length ? (page.cursor.next ?? undefined) : undefined
-                  } while (cursor)
-                  return JSON.stringify({ info: sessionData, messages }, null, 2) + EOL
-                })()
+              options.format === "markdown"
+                ? formatSessionTranscript(sessionData, messages(), options.thinking)
+                : JSON.stringify(
+                    await client.api.session.export({ sessionID: sessionData.id, sanitize: options.sanitize }),
+                    null,
+                    2,
+                  ) + EOL
 
           if (options.action === "copy") {
             await clipboard.write?.(content)
@@ -1026,10 +1017,10 @@ export function Session() {
                   </Show>
                 </Match>
                 <Match when={forms().length > 0}>
-                  <Show when={forms()[0]?.coalesce ?? forms()[0]?.id} keyed>
+                  <Show when={forms()[0]?.id} keyed>
                     {(_) => {
                       const form = forms()[0]
-                      return form ? <FormPrompt form={form} forms={forms()} /> : null
+                      return form ? <FormPrompt form={form} /> : null
                     }}
                   </Show>
                 </Match>

packages/tui/src/ui/dialog-export-options.tsx

@@ -9,11 +9,11 @@ export type ExportFormat = "markdown" | "json"
 
 export type DialogExportOptionsProps = {
   defaultThinking: boolean
-  onConfirm?: (options: { action: "copy" | "export"; format: ExportFormat; thinking: boolean }) => void
+  onConfirm?: (options: { action: "copy" | "export"; format: ExportFormat; thinking: boolean; sanitize: boolean }) => void
   onCancel?: () => void
 }
 
-type Active = ExportFormat | "thinking" | "copy" | "export"
+type Active = ExportFormat | "thinking" | "sanitize" | "copy" | "export"
 
 export function DialogExportOptions(props: DialogExportOptionsProps) {
   const dialog = useDialog()
@@ -22,6 +22,7 @@ export function DialogExportOptions(props: DialogExportOptionsProps) {
   const [store, setStore] = createStore({
     format: "markdown" as ExportFormat,
     thinking: props.defaultThinking,
+    sanitize: false,
     active: "markdown" as Active,
   })
 
@@ -30,6 +31,7 @@ export function DialogExportOptions(props: DialogExportOptionsProps) {
       action,
       format: store.format,
       thinking: store.thinking,
+      sanitize: store.sanitize,
     })
 
   const activate = () => {
@@ -38,6 +40,7 @@ export function DialogExportOptions(props: DialogExportOptionsProps) {
       return
     }
     if (store.active === "thinking") setStore("thinking", !store.thinking)
+    if (store.active === "sanitize") setStore("sanitize", !store.sanitize)
     if (store.active === "copy" || store.active === "export") confirm(store.active)
   }
 
@@ -52,7 +55,7 @@ export function DialogExportOptions(props: DialogExportOptionsProps) {
           const order: Active[] =
             store.format === "markdown"
               ? ["markdown", "json", "thinking", "copy", "export"]
-              : ["markdown", "json", "copy", "export"]
+              : ["markdown", "json", "sanitize", "copy", "export"]
           setStore("active", order[(order.indexOf(store.active) + 1) % order.length])
         },
       },
@@ -153,6 +156,46 @@ export function DialogExportOptions(props: DialogExportOptionsProps) {
           </text>
         </box>
       </Show>
+      <Show when={store.format === "json"}>
+        <box
+          flexDirection="row"
+          gap={1}
+          backgroundColor={
+            store.active === "sanitize"
+              ? theme.background.formfield.focused
+              : store.sanitize
+                ? theme.background.formfield.selected
+                : theme.background.formfield.default
+          }
+          onMouseUp={() => {
+            setStore("active", "sanitize")
+            setStore("sanitize", !store.sanitize)
+          }}
+        >
+          <text
+            fg={
+              store.active === "sanitize"
+                ? theme.text.formfield.focused
+                : store.sanitize
+                  ? theme.text.formfield.selected
+                  : theme.text.formfield.default
+            }
+          >
+            {store.sanitize ? "[x]" : "[ ]"}
+          </text>
+          <text
+            fg={
+              store.active === "sanitize"
+                ? theme.text.formfield.focused
+                : store.sanitize
+                  ? theme.text.formfield.selected
+                  : theme.text.formfield.default
+            }
+          >
+            Sanitize sensitive data
+          </text>
+        </box>
+      </Show>
       <box flexDirection="row" justifyContent="flex-end" gap={1} paddingBottom={1}>
         <box
           paddingLeft={4}
@@ -186,6 +229,7 @@ DialogExportOptions.show = (dialog: DialogContext, defaultThinking: boolean) =>
     action: "copy" | "export"
     format: ExportFormat
     thinking: boolean
+    sanitize: boolean
   } | null>((resolve) => {
     dialog.replace(
       () => (

packages/tui/test/cli/tui/form.test.tsx

@@ -15,7 +15,7 @@ import { TestTuiContexts } from "../../fixture/tui-environment"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
 import { createApi, createEventStream, createFetch } from "../../fixture/tui-client"
 
-async function mountForm(root: string, width = 80, coalesce = false) {
+async function mountForm(root: string, width = 80) {
   const state = path.join(root, "state")
   await mkdir(state, { recursive: true })
 
@@ -24,7 +24,7 @@ async function mountForm(root: string, width = 80, coalesce = false) {
   const events = createEventStream()
   const transport = createFetch(
     (url, request) =>
-      /^\/api\/session\/ses_test\/form\/frm_(?:test|other)\/reply$/.test(url.pathname)
+      url.pathname === "/api/session/ses_test/form/frm_test/reply"
         ? request.json().then((answer) => {
             replies.push(answer)
             return new Response(null, { status: 204 })
@@ -37,7 +37,6 @@ async function mountForm(root: string, width = 80, coalesce = false) {
     id: "frm_test",
     sessionID: "ses_test",
     title: "Authorization required",
-    ...(coalesce ? { coalesce: "authorization" } : {}),
     fields: [
       {
         key: "authorization",
@@ -72,7 +71,7 @@ async function mountForm(root: string, width = 80, coalesce = false) {
               <ClientProvider api={createApi(transport.fetch)}>
                 <ThemeProvider mode="dark" source={{ discover: () => Promise.resolve({}) }}>
                   <ToastProvider>
-                    <FormPrompt form={form} forms={coalesce ? [form, { ...form, id: "frm_other" }] : undefined} />
+                    <FormPrompt form={form} />
                   </ToastProvider>
                 </ThemeProvider>
               </ClientProvider>
@@ -127,24 +126,3 @@ test("includes external acknowledgements in progress", async () => {
     prompt.app.renderer.destroy()
   }
 })
-
-test("replies to every coalesced form", async () => {
-  await using tmp = await tmpdir()
-  const prompt = await mountForm(tmp.path, 80, true)
-  try {
-    prompt.app.mockInput.pressKey("right")
-    await prompt.app.waitForFrame((frame) => frame.includes("(acknowledgement required)"))
-    prompt.app.mockInput.pressEnter()
-    await prompt.app.waitForFrame((frame) => frame.includes("External action must be acknowledged"))
-    prompt.app.mockInput.pressKey("left")
-    prompt.app.mockInput.pressKey("c")
-    await prompt.app.waitForFrame((frame) => frame.includes("press enter to confirm"))
-    prompt.app.mockInput.pressEnter()
-    await prompt.app.waitForFrame((frame) => frame.includes("Acknowledged"))
-    prompt.app.mockInput.pressEnter()
-    await prompt.app.waitFor(() => prompt.replies.length === 2)
-    expect(prompt.replies).toEqual([{ answer: { authorization: true } }, { answer: { authorization: true } }])
-  } finally {
-    prompt.app.renderer.destroy()
-  }
-})